AI Did Not Lower the Floor. It Raised What the Architect Has to Carry.
Salvatore Sanfilippo, who created Redis, published an essay this year with a strange claim at its center. The reason Linus Torvalds matters is not the kernel he wrote. It is the moment he stopped writing it. “Among the maintainers of the famous open source projects, he was one of the very few that, very early… almost completely stopped writing code in order to concentrate on the leading of the project.”
The piece contains no measurements, no study, no survey. It is a thought piece, adapted from a video Sanfilippo recorded, and it deserves to be read as one. What it delivers instead of evidence is a role description. The role description is the part worth stealing.
The Job That Replaced the Code
Sanfilippo is specific about what Torvalds does with the time he freed up: “Linus holds the design concepts of the kernel, and continues to dialogue with everybody below him in the hierarchy.”
Holding the design concepts. That is the whole job. He is not reading every patch in the subsystems he delegated. He cannot. The Linux kernel produces more change per week than any single person can inspect, and it has for two decades. What Torvalds retains is the shape of the thing: what the kernel is for, which trade-offs are permanent, which direction a subsystem is allowed to drift, and which contributions are wrong in a way that no amount of code quality can fix.
The dialogue matters as much as the design. He is not an approval queue. He argues with maintainers, sometimes famously badly, and the argument is how intent survives contact with people who each see only their slice.
That combination is rare because it is uncomfortable. You are accountable for output you did not produce and cannot fully audit. Most senior engineers respond to that discomfort by reading more code, which collapses in the first busy week, or by delegating and looking away, which is how architecture rots.
We Are All Holding the Design Concepts Now
Sanfilippo makes the leap without hedging: “Now, when we program with the artificial intelligences, we are exactly that same thing. We are Linus Torvalds.”
The structural match is exact. An agent fleet produces more diff than you can read. Every one of those diffs was written by something that saw a fragment of the system and none of the history. Your leverage is not in the reading. It sits in what you hold: the design concepts, the list of implementations that should exist and the longer list that should not, and the standing dialogue that keeps the fragment-writers pointed the same way.
We have written before about fleet operations inverting single-agent best practice and about the discipline a workflow needs to survive that inversion. Those describe mechanics. Sanfilippo is describing the seat. The mechanics only work when someone is actually sitting in it.
The Democratization Story Runs Backwards
The pitch that arrived with coding agents was that programming would open to everybody, because the hard part was the syntax and the syntax is now free. Sanfilippo rejects the premise directly: “Vibe coding is a wrong idea of what automatic programming is.” His replacement is a description of scarcity, not abundance. “Automatic programming as well has need of talents that talk with the agents, that check the ideas, that know which are the implementations to do and the ones not to do.”
Read that as a hiring spec and the inversion becomes concrete. Talking to agents productively requires knowing what you want before you ask. Checking the ideas requires a model of the system good enough to spot a plausible answer that is wrong. Knowing which implementations not to do is the most expensive skill in software and the one no agent supplies, because it depends on constraints that live outside the repository: the migration you already committed to, the customer who cannot take downtime, the abstraction you are deliberately not building yet.
Sanfilippo hand-waves a number for how many programmers could have written a minimal working Unix kernel, and flags it as a guess: “0.1%, one in a thousand, one in ten thousand.” Treat that as rhetoric rather than data. The argument survives without it. What agents commoditized is the implementation, and implementation was never the bottleneck on serious systems. The bottleneck was judgment about what to implement, and agents made that judgment govern more output per hour than it ever has.
Where the Comparison Is Too Comfortable
Sanfilippo adds an aside worth pushing back on: that leading agents is easier than leading humans, because there is no context switching and no personality management.
He is right about the cost side and wrong about what the cost was buying. A human maintainer who thinks your design is wrong tells you so. They stall, they file a counter-proposal, they escalate, they refuse the patch. That friction is expensive and it is also the only unsolicited error detection a technical leader gets for free. Torvalds is not just steering the kernel. He is being steered back by people with standing to say no.
An agent does none of that. It will implement a bad architecture cheerfully and well, and the better it is, the longer the bad architecture survives inspection. Remove the pushback and you have not removed a management overhead. You have removed a control, and you now owe your organization a replacement for it: a red-team review, an adversarial second agent, a human reviewer whose explicit job is to argue with the design rather than with the diff.
The Same Seat Outside Engineering
This posture generalizes to any function whose production has outrun inspection, which is now most of them.
A legal team running contract-review agents reads a fraction of the clauses the agents touched. A finance team with agents building reconciliations traces samples, never every figure. An HR function generating job descriptions, screening summaries, and policy drafts at machine volume has the same arithmetic problem. In each case the reflex is to demand full review, and full review is arithmetically dead. The alternative relocates control: someone holds the design concepts of the function, defines what must never be true, and audits the boundary instead of the volume.
That person needs more expertise than their predecessor did. They are approving a category of output rather than an instance of it, and a category error propagates silently across thousands of documents before anyone notices.
Do This Now
Take one function where agent output already exceeds what your team reads. Write down, in one page, the design concepts a human must hold for that function: the decisions that are permanently settled, the implementations that are forbidden and why, and the two or three failure modes that would be unrecoverable. Name the person who holds it. Then schedule the dialogue, a recurring session where that person argues with the agents’ output about intent rather than correctness.
While that name stays blank, what you have is speed without governance.
This analysis synthesizes Being Linux Torvalds (antirez.com, 2026).
Victorino Group helps organizations define who holds design intent when agent output exceeds human inspection. Let’s talk.
All articles on The Thinking Wire are written with the assistance of Anthropic's Opus LLM. Each piece goes through multi-agent research to verify facts and surface contradictions, followed by human review and approval before publication. If you find any inaccurate information or wish to contact our editorial team, please reach out at editorial@victorinollc.com . About The Thinking Wire →
If this resonates, let's talk
We help companies implement AI without losing control.
Schedule a Conversation