Jarvis Didn't Build Iron Man

"Tony Stark was able to build this in a cave... with a box of scraps."

Here's the part everyone forgets about that line: it's a complaint.

Obadiah Stane says it, and he says it because he can't do it. He has Stark Industries. He has an R&D division, a warehouse, a budget, and — crucially — the actual wreckage of the Mark I on a table in front of him, being reverse-engineered by a team of very smart, very well-funded people. He has every tool that exists. What he doesn't have is Tony Stark. So the most advanced weapons company on the planet builds a bloated, lumbering failure, and the guy who started with a box of scraps flies.

I think about that line more than is healthy, because lately I get a smaller, quieter version of it in my pull requests. Not a supervillain monologue. Just an emoji. 😐.

The cave is the whole argument

The Mark I gets built in a cave with a car battery, a crate of decommissioned missiles, and a soldering iron. The first arc reactor — the chest piece that keeps Tony alive and powers the suit — gets built in that same cave, out of the same junk. There is no Jarvis. There is no lab. There is no AI whispering suggestions. There is a dying man, a colleague, and a deadline measured in heartbeats.

That is where the creative leap happens. Not later, in the glossy workshop with the holograms. There, in the dark, with nothing. Everything after the cave is refinement of an idea that already existed the moment Tony decided he was going to build a way out.

When he gets home, then Jarvis shows up. And yes — the Mark II and Mark III come fast, and they come good. He iterates on the arc reactor, drops the icing problem, tunes the flight surfaces, paints it. Jarvis runs the numbers, holds the model, catches the obvious mistakes. It looks, from the outside, like the AI is doing the building.

But watch what's actually constant and what's actually variable. Jarvis is a fixture — there for the failed prototypes, and there for anyone who happened to own the house. The variable is the person giving the orders and deciding when the tool is wrong.

And on the two choices that made the suit iconic, that's exactly what Tony does — he overrules it. When the Mark III renders in gold, Jarvis needles him for the ostentation; Tony calls for hot-rod red anyway, and Jarvis's only reply is a dry crack about how well that'll help him keep a low profile. Tony's next word is "paint it." When it's time to fly the Mark II, Jarvis wants caution — terabytes more math before anything leaves the ground — and Tony tells him you sometimes have to run before you can walk, and takes off. The two things everyone on Earth knows about Iron Man, that it's red and that it flies, are both the human overruling the machine. Jarvis is the workshop. Tony is the reason it produces anything — and Jarvis didn't design the suit. Half the time he was arguing against it.

Stane had the better tools and still lost

Here's the proof, and it's sitting right there in the third act.

Stane doesn't build his own thing from a napkin sketch. He recovers the real Mark I, hands it to an entire engineering team, and tells them to make it bigger. They have more compute, more money, more people, and the finished reference design in their hands. By any resourcing metric you'd put in a budget deck, they should win easily.

They can't miniaturize the reactor. Stane's lead scientist finally has to tell him, to his face, that he isn't Tony Stark — that's the whole problem, and no amount of tooling closes the gap. Stane has to physically steal the reactor out of Tony's chest, because his team of professionals with every advantage could not reproduce what one man improvised in a cave.

If tools were the thing that mattered, Stane wins in an afternoon. Tools were never the thing that mattered.

The emoji

So: my pull request. It's a real piece of work — a direction-aware property resolution change to the PHP engine that collapses private(set) and protected(set) write costs down to the price of a plain public write. It isn't a bug fix; the cost it removes was a known, accepted tradeoff from when asymmetric visibility first shipped, and clearing it is groundwork for feature work I'm building on top. During review a maintainer did find a genuine soundness hole in my first cut — the fast path could be bypassed through the optimizer's shared cache slots — which I closed with a regression test, crediting the reviewer who caught it. It is, I'd argue, exactly the kind of contribution open source is supposed to want.

At the bottom, I left a tag I always leave: 🤖 Generated with Claude Code.

The response to that tag was 😐.

I want to be fair about what that emoji is doing, because there are two very different things it could mean, and only one of them is the Stane error.

The Stane error is the reflex that says: the tool did this, so the credit — and the competence — belongs to the tool, not to you. That the box of scraps built the armor. That Jarvis built Iron Man. It's the belief that because you can see the machine, the human behind it must have been optional. That reflex is as wrong in my PR thread as in Stane's warehouse, and for the same reason: the tool is a constant, available to everyone, and it does not by itself produce the thing. If the AI were the author, every one of the millions of people with the same subscription would be shipping engine patches. They are not. The judgment about what to build, and the far harder judgment about whether the result is actually correct, does not come from the model.

The hardest man in the room already conceded this

If you want an authority on human-centric, quality-obsessed, deeply suspicious engineering, it's hard to beat Linus Torvalds. In 2024 he was calling most AI messaging marketing hype and saying he'd cheerfully ignore it.

This week he put his foot down in the other direction. In a kernel mailing list thread about an AI patch-review tool, he wrote that Linux is not one of those anti-AI projects — and that anyone who has a problem with that can do the open-source thing and fork it, or walk away. He frames AI as just another tool, one whose usefulness is no longer seriously in question if you've actually used it.

And notably, he doesn't pretend it's a magic wand. He calls it a painful tool too — it adds to maintainer workload, and it "keeps finding embarrassing bugs," which is a backhanded compliment if I've ever heard one. He even points out that natural intelligence isn't always that impressive either. That's the whole posture I'm arguing for: a tool with real failure modes that a competent person still chooses to wield, on purpose, because the output is worth the trouble.

The guardian of the most consequential codebase on Earth looked at AI tooling and reached for the same word I keep reaching for. Tool. Not author. Tool.

The part I have to be honest about

But here's where I stop being defensive, because the emoji thread didn't end at 😐, and the follow-up made me a little uncomfortable in a useful way.

Once people actually said what they meant, the objection wasn't "your code is slop." Nobody argued that. A maintainer read the change closely enough to find a real bug in it — the human review process worked exactly as intended, and the patch was good enough to be worth that scrutiny. What actually bothered people was that I'd let the tool do my talking too. My comments were long, formal, over-explained; they reiterated things back at people who'd just said them; they read like a machine narrating rather than a contributor conversing. And that's… fair. It lands.

Which, if anything, strengthens the Tony Stark version of events. Tony lets Jarvis run the numbers. He does not let Jarvis do his talking. His voice in the room is unmistakably his — flippant, impatient, human. He never once outsources his presence. The lesson from my thread isn't "hide the tool." Disclosure is right, and the maintainer who defended it was right to. The lesson is: disclose the tool, and keep your own voice in the room. Let the machine amortize the visibility check. Don't let it draft your side of the conversation.

The objection I'm not answering today

There's a heavier objection to all of this, and I'm not going to pretend it isn't sitting in the room. It isn't "the tool did your work" — it's "the tool shouldn't exist in the form it does." That these models were trained on mountains of other people's work without asking, and that everything they touch is fruit of a poisoned tree. That's a genuinely different argument, and a more serious one, because it doesn't dispute that I'm the author. It disputes whether the workshop was built with stolen lumber.

I have things to say about that — about whether an evidentiary doctrine from criminal law actually transfers to a tool, and about where a single contributor's responsibility begins when they didn't do the scraping but do reap the speed. But none of it fits in the margins of this essay without collapsing it, and the objection deserves more than a paragraph bolted onto a piece about something else. So I'll owe you that one. It's a different essay, and I'll write it.

The footnote, not the confession

The box of scraps didn't build the armor. Jarvis didn't build the armor. Tony built the armor, twice — once with an AI and once without — which is the only controlled experiment that matters, and the human variable won both runs.

"Generated with Claude Code" is not a confession that the tool did the thinking. It's a footnote. It's a citation. It says this is how the work was produced, the same way you'd note the compiler version or the fact that a transcript was machine-transcribed. The thinking — the decision about what to build, and the much harder decision about whether it's right — was mine, and I'll defend every line of it in review, which is exactly what I did.

Stane had every tool and no Tony, and he lost. Torvalds has every reason to be precious about his craft, and he called it a tool and moved on. So the next time a green field of resources fails to produce what one person improvised out of scraps, ask which variable was actually missing.

It was never the box of scraps.

And if you still don't like the tag at the bottom of my commits — well. You can always do the open-source thing and fork off.