The wrong scarcity
the old regime one scarcity, the hands; review is cheap because the diff arrives compressed person problem → engineer formed by osmosis → ⛛ write the code by hand, slowly automated tests · CI, a training program person lead reads the diff, a shared codebook → approve → merge → the firm absorbs it the arms race generation free, 10–20× the code; the queue moves to comprehension, onto the lead person problem → engineer + a team of agents agents generate 10–20× the code, with its own dictionary automated tests pass trivially, or are deleted person ⛛ lead reads the dictionary → merge, or bottleneck → incident on the lead proposed the queue moves to where a page is read, and to the people the risk requires person ⛛ plan, one page: what changes, what stays invariant, which joint, no new words agents build inside the plan → self-check: tests, build, lint run and shown person compression: the talk, written, with its ratio to the diff automated required CI agents AI review: hunters, a vote, three rounds → security review, which can block person ⛛ approval by risk: 0, 1 or 2 people; the tier set by the change, never by the author automated merge queue → flag, employees first → staged release person watch, roll back: the author and on-call → pager: the author, for a period automated incident → eval; the reviewer is rescored daily ⛛ a yield sign, where the change waits for a person
The sessions
…à un sçavant auteur qui enferme le plus de realités dans le moins de volume qu'il peut.
…like a learned author who encloses the most reality in the least volume he can.
—Leibniz, Discours de métaphysique, V (1686). Text as established by Henri Lestienne (Alcan, 1907). The marginal variant in Leibniz's own hand is blunter: ce qui renferme plus de réalité en moins de volume est plus parfait—what holds more reality in less volume is more perfect.
Some years ago I wrote a pull request of 20,000 lines. It was a foundation, the one a business has since been built on; it was too large for anyone to approve and too important for anyone to wave through, so I did what the size demanded. I chose a few of the engineers who would have to live with it, gave them the critical sections, and for weeks we sat together, hours at a stretch, line by line, while I said why each piece was where it was and what would break if it were elsewhere. By the end they could have rejected it. That was the point. The review was not a check on the code; it was the code entering their heads, and the weeks were not the overhead of the work but the work. What crossed the desk in those sessions was never the 20,000 lines, which they could have read alone. It was the theory that made the lines necessary, which they could not have read anywhere, because it had never been written, and when we stood up at the end they were the people who could change that system without asking me. A firm's convention was made of such sessions, compounded: idioms and styles, but mostly a familiarity with the patterns in place and the choices behind them, held in common by people who had spent years reading the code that was already there and having their own code read. No document taught it, because none could have. The engineer so formed produced minimal changes, not because he was told to be brief but because he could see where the structure already had space, and his review was easy because it was incremental: a small diff against a shared understanding, read by someone who shared it. I could approve in minutes what had taken a week. What I approved was mostly already mine; what he submitted was mostly already ours.
The long pull request has come back, and it has reversed direction. It arrives now from the other side of the desk: 15,000 lines, design choices and new patterns pushed into the core infrastructure, generated by a team its author commands and does not understand, and it comes to me because I am senior, whatever that means. It cannot be sat through, because this time nobody at the desk can give the sessions. The author can describe it—here is the module, here is what the new term means, here is where it is called—and he cannot explain it: why this decomposition and not another, what it forecloses, where it will break, what it will cost to change. What arrives for review is a private creation, with its own jargon, its own corner cases with their own failure modes, and a prose that is the model's and no one's in the firm, and the burden of unpacking it is not large. It is unbearable: it cannot be borne by one person at the rate it arrives. Mathematicians say the same of the machine proofs released this autumn: technically readable, fluent on every triviality, hurried at the one step where the decision was made, and understood in full by nobody. OpenAI announced on September 8, 2026 that a system of some 10,000 agents had produced a blow-up solution for Navier–Stokes; on October 6 it released 722 manuscripts claiming 377 results from roughly 4,000 problems attempted, among them a quasi-Riemann hypothesis confining the zeta zeros to a strip. Terence Tao, on the 165-page Navier–Stokes argument, to The New York Times (Oct 16, 2026): "no expert I've talked to has actually understood the whole argument." On the style itself, his ICM essay Mathematics in the age of AI (Jul 2026) observes that machine exposition lingers on trivialities and hurries past the novel step; the analytic number theorists now reading the quasi-Riemann papers say the same of them, correct as far as anyone can tell and far below the field's standard of exposition (Quanta, Oct 19, 2026). I can ask the agents to review the code and to test it, and I do. But the review was never only verification. It was the moment the firm's understanding absorbed a change, the moment ownership passed from the one who wrote it to the ones who would live with it; in one direction it was absorption and in the other it was apprenticeship, and both ran on a theory being present in the room. Absorption does not happen at the speed of generation. Apprenticeship, without the sessions, does not happen at all.
What has emerged is an arms race for entropy. The pull request arrives as an offering and a dare: here is what I've produced; you deal with it. The upside is the author's, and it is everything the firm can see: visible, countable, immediate, wearing the look of ambition and the feel of mastery, praised as volume has always been praised when no one is measuring anything else. The downside is deferred, dispersed, and someone else's. It is paid first in attention, by whoever must read the thing; then in incidents, by whoever is on call when a corner case no one understood meets the world; last in the slow loss of a theory the firm no longer shares; and when the bill comes due it is made out to the reviewer. You are the lead. Why didn't you review better? Why did you let me merge? The author, by then, is generating again. None of this is malice and most of it is not even awareness; it is the structure of the incentive once generation is free: credit at the speed of output, cost at the speed of comprehension, and no one standing between the two. Each engineer, alone with his team, does what the incentive rewards, and the understanding his output consumed is replaced by no one. Compression is the only skill left; anyone can generate. I believed that sentence before I could say why, and the why turned out to be larger than the review queue.
The model I was running was the benevolent dictator's, and I believed in it; I was one. For years I owned the firm's core system, and owning meant being the gatekeeper of the business logic and the maintainer of the codebase, which in practice meant reviewing and approving every pull request. I was proudest of the architecture: a set of abstractions enforced so that a feature could be added with little code and less review, each concern in its own place, the parts forbidden to talk across their boundaries, side effects confined to the few places where they were allowed to happen, identities carried monadically so that an unresolved one could never pass for a resolved one. A good abstraction makes the next feature boring. The model has ancestors. "I will contend that conceptual integrity is the most important consideration in system design," Brooks wrote, and that it comes from one mind or a very few, and that the way to get one mind's design built by many hands is the surgical team, one surgeon who cuts and ten who hand him things. The Mythical Man-Month (1975), chapters 3 and 4; the surgical team is Harlan Mills's chief-programmer team. It was never adopted at scale because ten people per surgeon was unaffordable. Every engineer now runs one, and a hospital of surgeons has no conceptual integrity. The master mason of the Bauhütte touched every stone; the stones now arrive precut, and the master's hands are the bottleneck. The dictator did not fail to scale. He was never meant to scale; he was meant to keep one mind, and he could, as long as the many hands produced less than one mind could absorb. Tao, asked two weeks after the October release whether he felt lucky to have had his career before this, answered for a whole profession:
We are seeing the end of the romantic era of mathematics, the age of heroes, which happened in other disciplines centuries ago, as early as the industrial revolution. But somehow mathematics held on, and we had our idiosyncratic traditions—we all use blackboards; we do a lot of one-on-one advising of individual grad students; we have these mythological stories about Andrew Wiles staying in his attic for seven years. I think we are moving to an industrial era where math will become much more large-scale, we work in big teams, more like the other sciences, which have already had to adapt to industrialization. And something will be lost. There was something romantic about the heroic age, and hopefully we will keep some of it—at least in our educational system we will emphasize traditional ways of doing mathematics first, just as we teach kids to do arithmetic by hand before giving them calculators. We are entering, rather unwillingly, a new era where exciting new things are possible but some things are being lost, and the question is what can we keep that is valuable and what can we let go of.
—Terence Tao, Numberphile, October 15, 2026. No More Heroes, transcript lightly edited for speech. He adds that hero worship had its downside, winners and losers; and that the heroic era was "slow and maybe inefficient in ways," which is the old regime's ledger too.
The benevolent dictator was engineering's hero, and he ends the same way, not defeated but outproduced. Put the 15,000-line pull request in front of him. How does he review it, and with what? Seniority runs the wrong way for the task: the scope one answers for widens with every year, and the hours of unencumbered attention, the only hours in which a diff can be read, shrink with it, so that the firm sends its hardest reading to the person with the least time to read. That is a second arms race, scope against attention, and the senior was losing it before the agents arrived. He does not review it. He decides whether it should have been written, and under his model there is no stage at which that decision is made, because the dictator reviews what exists and this already existed. Review every line and he is the bottleneck; review none and he is the liability. Two moves remain to him, to compile himself and to delegate the diff while keeping the decisions, and he must make both.
So the model is broken, not strained; its one rule can no longer be followed by anyone. The practice of software engineering, all of it—how we hired, how we trained, how we organized, what we were proud of, who owned what, how we decided what was good—was built around one scarcity, the cost of producing code. It ran, all along, on a second scarcity that went unorganized because it was free: the understanding that production threw off as exhaust, when production was slow and done together. Agents removed the first scarcity in about a year. The second now binds everything, and the institutions built for the first are discovering, one at a time, that they priced the wrong one. The repair is a repricing, of what is scarce, of who pays, and of what is counted, and a repricing begins with a ledger.
The ledger
What the year did to me comes before what it did to the firm, because I am not writing from outside the problem. Against 2025 I generate an order of magnitude more code, on every frontier model as it appears, and the tokens cost the firm about what one more engineer would; I read many times what I read then, most of it in fields I do not know, and I have been telling people that speed reading has become a critical skill of the age, above all over material one is not familiar with. I spend a fraction of the time I used to with other engineers, and the time with juniors went first; I have almost stopped speaking to them, partly because the agent now answers what they used to bring to my desk, and partly because the firm, acquired, became an enterprise and doubled its engineers in a year, so that there are twice as many of them and the desk between us became an org chart. We cancelled almost all of our standups, because there was almost nothing left to stand up about: nobody needed anyone else to finish. I feel more productive, and I am less patient. The impatience has a specific object. It is being made to compress other people's output—to supply, after the fact and at my own expense, the theory it arrived without—and the annoyance is a tell, because the compression was always my job; I used to do it for people, in sessions, and I am now asked to do it for a machine's output in the name of a person who cannot help. The data the labs collect on their own engineers say that none of this is particular to me. Anthropic surveyed its staff and found Claude had become the first stop for questions that used to go to a colleague, one engineer routing 80 to 90% of his questions to it; roughly half reported no change in collaboration and the rest reported less, and the one who put it best said, "I like working with people and it's sad that I 'need' them less now," adding that the junior people no longer came to him with questions. How AI is transforming work at Anthropic (Dec 2, 2025; 132 engineers and researchers surveyed, 53 interviewed, with 200,000 internal Claude Code transcripts). Some engineers reported practicing without the tools to stay sharp; some missed the flow state; a senior noted the juniors got answers faster and learned faster, which is true and is also the problem. The Stack Overflow numbers are that picture from outside: in the 2026 survey, 70% of developers say their first step on hitting a problem is to ask an agent, 64% visit the site less for simple questions, 29% ask fewer questions and 26% contribute less, against 1% who contribute more (2026 Developer Survey, 30,903 respondents, fielded Jun 23–Aug 5, 2026). The question that used to be asked of a person is now asked of nobody in particular.
2025 2026 (my own ledger)
tokens — $15–20k a month, every frontier model
code generated 1× 10–20×
material read 1× ~10×, mostly unfamiliar, read fast
engineering staff 1× 2×
time with engineers most of the week ~1/10, almost none with juniors
standups daily cancelled
review read the diff; approve asked to compress what arrived
patience — less
productivity (felt) — more
who answers a question before now
──────────────────────────────────────────────────────────────────────
junior → senior daily almost never
senior → senior (the theory argued out) weekly what survives
anyone → the agent — first, 70% of the time
The firms whose software moves money are nearest my own trade and the most sober about it, because their incidents have regulators. Jane Street, which runs on OCaml and builds its own tools, reported in October that 45% of the features released across the firm now begin as an agent kicked off from a Slack message, and Ron Minsky, its CTO, described what that has done to the engineer's day with nothing to sell:
…it's also kind of tiring. There's a relaxing piece in the middle that you just get less access to. […] Human understanding is as critical as ever the whole way through. […] This verification piece is as hard as it ever was.
—Ron Minsky, Jane Street, Signals and Threads, October 16, 2026. The Changing Craft of Programming, with John Crepezzi; transcript lightly edited. Minsky's engineer "felt like 10% of his time was thinking really hard and deeply about what to do," and now "does that 10% and then sends a model to do the other piece"; what is lost is the middle, where one relaxed and also learned, because "you spend that 10% thinking hard about what to do, and it turns out the result of the 10% is you are wrong," and "that knitting time is also a time where you learn important things." The firm's instructive case is an engineer who had an agent implement a change and found that "a lot of the work that he would've done in the process of authoring it himself, he now had to do in the process of reviewing it."
The first scarcity is gone, and gone without remainder: an average engineer with a frontier model now ships software more powerful and more complex than the best engineers could a few years ago. The constraint that moved first was not review but product, and the clearest witness is Andrew Ng, who has spent a career teaching people to build and now finds the building the easy part:
I don't see product management work becoming faster at the same speed as engineering. I'm seeing this ratio shift. […] Just yesterday, one of my teams came to me, and for the first time this team proposed to me not to have 1:4 PM/engineers, but to have 1:0.5 PM/engineers. […] For the first time in my life, managers are proposing having twice as many PMs as engineers.
—Andrew Ng, Y Combinator AI Startup School, June 2025. To No Priors that August he put the reason in a sentence: "The bottleneck is deciding what do we actually want to build."
A ratio that once encoded a scarcity of hands now encodes a scarcity of judgment. Prototypes are free, and therefore worthless; the expensive artifact is the sentence that says which prototype is the product, and no one has sped up the writing of that sentence.
The second scarcity has been measured. Across 700 firms, the adoption of coding agents raised the code written by a third and the software finished by nothing anyone can distinguish from zero; the difference waited in the review queue. Fiona Chen and James Stratton, Artificial Intelligence in the Firm: Bottlenecks in Software Production (Harvard working paper, Aug 2026); their own summary is that "code review becomes the bottleneck."
After a firm adopts coding agents (718 firms, 725,000 workers, 2021–Mar 2026) ─────────────────────────────────────────────────────────────────────────── lines of code added, per worker-month +30% (≈ +1,500 on a base of ≈ 5,000) commits +20% pull requests opened +23% ─────────────────────────────────────────────────────────────────────────── time, pull request → merge +49% (≈ +3.5 days on a base of 7) pull requests sent back for revision ≈ 2× review comments per pull request +35% share of workers doing review +14% ─────────────────────────────────────────────────────────────────────────── issues resolved / epics completed no significant change employment no significant change
The controlled measurements of individuals are less flattering still. When METR timed experienced open-source maintainers on their own repositories in early 2025, those allowed the tools took 19% longer while believing they had been sped up; a year later the same lab found a modest speedup and declared its own numbers unreliable, because the developers keenest on the tools had declined to take part and the rest had withheld the tasks they did not want to do by hand. METR, uplift update, Feb 24, 2026: 57 developers, 143 repositories, 800-plus tasks; returning developers measured at roughly 18% faster, new recruits at roughly 4%, confidence intervals straddling zero. The one durable finding across both studies is that the felt speedup and the measured one disagree, which should be kept in mind when I report feeling more productive. Inside the firm that sells the agents the numbers run one way: in the second quarter of 2026 Anthropic's typical engineer merged 8× the code per day he had two years earlier, changes landing in its monorepo went from 2,500 a day in May to 30,000 in September, and the company files the consequence under Amdahl's law, that speeding up every stage but one makes the one the schedule. When AI builds itself (Anthropic, Sep 2026) for the eightfold figure and the Amdahl framing; How the Claude Code team does code review (Oct 15, 2026) for the monorepo count, for the estimate that the model now writes about 90% of its own product's code, and for the admission that matters most here: nobody on the team keeps a full mental model of Claude Code any more, and engineers ask the model to write explainers for the parts they need. Their March Code Review launch gave the shape of the review problem: on pull requests over 1,000 lines, 84% draw findings, averaging 7.5 issues; under 50 lines, 31% and half an issue. Findings scale with the diff. Comprehension does not. The team at OpenAI that forbade itself hand-written code shipped a million lines in five months, pushed nearly all review to agents, and found its bottleneck had become human QA. Its engineer's account of what the experiment was for is the plainest thing any lab has published about the trade:
We needed to understand what changes when a software engineering team's primary job is no longer to write code, but to design environments, specify intent, and build feedback loops that allow Codex agents to do reliable work. […] What's become clear: building software still demands discipline, but the discipline shows up more in the scaffolding rather than the code.
—Ryan Lopopolo, OpenAI, Harness engineering, February 2026. The post compresses its division of labor to four words, "Humans steer. Agents execute." It also reports that the team's one scarce resource was human time and attention, and that the architecture one usually postpones until there are hundreds of engineers had to be enforced by linters from the first week for a team of three.
Verification is being automated almost as fast as generation; agents already review agents. What is not being automated at all is the third stage, the one Tao calls digestion: understanding a result, placing it in context, being able to explain it. He saw it in April, before the flood:
We are transitioning in mathematics from an era of proof scarcity to an era of proof abundance, but our mathematical infrastructure and culture has not yet adapted to this. […] There is now a strong (and growing) impedance mismatch between the three core components of mathematical problem solving: proof generation, proof verification, and proof digestion.
—Terence Tao, April 27, 2026. Mathstodon.
Substitute code for proof and pull request for solution, and every clause survives. The abundance arrived in October in a form nobody could miss, 722 manuscripts in a single day, and Tao, who had spent three years as the field's most patient advocate of engaging with the companies, wrote two days later:
None of the humans involved in these proofs are available to take questions, give talks, attend conferences, submit papers to journals, train students, or otherwise participate in the subsequent development of these results.
—Terence Tao, October 8, 2026.
A week later he told the Times he no longer saw a way to engage constructively. His contribution to 100+ reactions to 100+ solutions (Proofs and Prompts, Oct 8, 2026), and the Times interview of Oct 16, in which he describes himself as on a war footing and doing very little mathematics. What he did next is the better guide to what the work is now: within two weeks he had posted a sketch of one of the released results, the nine-page machine proof that Siegel zeros do not exist, rebuilt by hand from Ben Green's digestion with the declared help of an open model. Digestion is not being automated. It is being done by Tao, at night, two weeks later. What he had seen coming is in the sentence of his that explains the most, from the ICM essay: digestion was never rewarded because it arose on its own, as a byproduct of generation, and a community that never had to pay for a thing does not notice when it stops being free. It was truer of us. Writing code slowly, together, did three things at once. It produced the code. It produced the engineer, who learned the system by building a small piece of it under the eyes of people who knew the rest. And it produced the shared theory of the system, because every piece had to be fitted to the others, and fitting was a conversation. Only the first of these was ever measured, because only the first was scarce; the other two came free and were therefore invisible, the way air is invisible until it is thin. Agents took over the first. No one decided to stop the other two; they stopped on their own, because they were never separate activities but side effects of the one that was automated. A resolved ticket is a verified artifact. A codebase is a digested one. Our metrics count the first. Problem-solving, Tao says of his discipline, was only ever a proxy for understanding, accurate while the only way to solve a problem was to understand it, and loose the day a problem could be solved without being understood. Goodhart's law, in the form the ICM essay gives it: when a measure becomes a target it ceases to be a good measure. Lines of code were a terrible measure that nobody targeted because nobody could; now anyone can. Code was ours. Its volume is now the easiest thing in the firm to increase, and it rises as what the firm needs falls.
What understanding is
If understanding is the scarce thing, it helps to know what it is, and the cleanest statement of it predates software by three centuries. Leibniz, explaining why nothing God does is disorderly, writes:
Car, supposons, par exemple que quelqu'un fasse quantité de points sur le papier à tout hasard, comme font ceux qui exercent l'art ridicule de la geomance. Je dis qu'il est possible de trouver une ligne geometrique dont la notion soit constante et uniforme suivant une certaine regle, en sorte que cette ligne passe par tous ces points, et dans le même ordre que la main les avait marqués. […] Mais quand une regle est fort composée, ce qui luy est conforme, passe pour irregulier. […] Mais Dieu a choisi celuy qui est le plus parfait, c'est à dire celuy qui est en même temps le plus simple en hypotheses, et le plus riche en phenomenes.
Suppose, for example, that someone makes a quantity of points on paper entirely at random, as those do who practice the ridiculous art of geomancy. I say it is possible to find a geometric line whose notion is constant and uniform according to a certain rule, such that this line passes through all these points, and in the same order the hand marked them. […] But when a rule is very complex, what conforms to it passes for irregular. […] But God chose the one that is most perfect, that is, the one that is at once simplest in hypotheses and richest in phenomena.
—Discours de métaphysique, VI. Same edition. Chaitin built algorithmic information theory on this paragraph and reduced it to three words, comprehension is compression (Gregory Chaitin, Meta Math!, 2005; Kolmogorov, 1965).
Any set of points admits a curve. The curve counts as a law only when it is shorter than the points; when the rule is as complicated as the facts it governs, the facts are for every practical purpose random, and Leibniz's word for that is irregular. This is the whole theory of code review, and I did not know I held it until the premises changed. When I review a change I am looking for the rule that explains the diff—this moves the pricing logic behind one interface and nothing else changes; this adds a column and threads it through four reads—and the short description is what I approve, while the diff is what I sample to check that the description is true. A reviewable change is a compressible one. A pull request that admits no description shorter than itself is, by Leibniz's criterion, noise, and reading it costs its full length. My 20,000 lines admitted a description; it took weeks to deliver, from someone who held it, and the weeks were the price of the size. With no one to deliver it, 15,000 lines are not reviewed but endured. Compression is relative to what the reader already knows, which is where the firm enters. A message is short in proportion to the codebook the sender and receiver share; osmosis was a slow way of installing one codebook in several heads, and "the firm," as the engineers called their convention, was the codebook. Shannon's codebook (A Mathematical Theory of Communication, 1948): the length of a message is not a property of the message but of the agreement between the parties about what the symbols mean. The agent does not share our codebook. It brings its own, drawn from the whole internet, so every change now ships with its dictionary attached, and reading the dictionary is the review. Naur said this about programs forty years before anyone could generate one:
The proper, primary aim of programming is, not to produce programs, but to have the programmers build theories of the manner in which the problems at hand are solved by program execution.
—Peter Naur, "Programming as Theory Building" (1985). Microprocessing and Microprogramming 15 (1985). The program, on his account, is the theory its builders hold of it and the text a residue; a program whose theory nobody holds is dead however well it runs, because a new team handed the text without the theory can only make modifications that are locally plausible and globally wrong, which is a fair description of agentic drift. Brooks's conceptual integrity is the other half of the thought: a theory is held by a small number of heads or not at all.
Tao, asked forty-one years later why the companies keep announcing solved problems, said what the artifact becomes once it can be produced without the theory it used to require:
We as a mathematical community also placed a lot of value on solving these problems, because traditionally, when a human solves one of these problems, they understand it very well, they can explain it very well, they can pose new problems based on the work they did, they can train students, and so it all kind of tied together. When we give prizes for solving problems, really we were rewarding this broader activity, and the problem solving was just the easiest thing to use as the metric. But now, almost incidentally, these companies are almost by accident solving these problems—it's just a useful benchmark for them to train their models—and this was kind of this toxic waste byproduct, if you wish, which they then had to somehow deal with, or we had to deal with. So we do need to make it much more clear that we don't need these problems solved for their own sake. We want the broader understanding and the insights.
—Terence Tao, in conversation with Yu Deng, SAIR podcast, October 2026. Recorded Oct 19, 2026; transcript lightly edited for speech. Naur's program and Tao's solved problem are one artifact under two names, and what is left when it is produced alone is what Tao calls it.
In the old regime the reviewer and the author held the same theory and the diff was a message between them. In the new regime the author may hold no theory of his own pull request, and what he holds instead deserves its own name. The dictionary is everything that can be recovered from the text. The author can produce all of it on demand, and so can any other agent handed the same text, which is the sign that it is the dictionary and not the theory. The theory is what Naur meant: why the system is cut here and not there, which alternatives were rejected and at what cost, what the design forecloses, where it will fail first when the world moves, what a proposed change will do to parts of the system the change does not touch. None of this is in the text. An author with the dictionary can answer what and where; only an author with the theory can answer why and what if. He can read his pull request aloud. He cannot take questions on it. And the agentic pull request is the first artifact in the history of the practice that arrives with a complete dictionary and no theory at all, because the agent's theory, insofar as it has one, lived in a context window that was discarded when the diff was emitted. Yu Deng draws the gap for mathematics as two boundaries: within the set of all questions, the boundary of those that have proofs, and within those, the boundary of the proofs that someone understands. "Before, the second boundary was trivial, because if there is a proof then someone will be able to understand it. Now, if only the AI knows a proof, this creates a second boundary." Yu Deng, University of Chicago, in the SAIR conversation of Oct 19, 2026, lightly edited for speech. The dictionary is everything inside the first boundary; the theory is what lies inside the second.
The reader's side of the law explains the speed reading, a skill and a danger for opposite reasons. Over material I know, reading fast is compression at work: I am not reading the points, I am checking the curve, and a page in a domain whose codebook I hold costs a glance because I already know what it will say and need only see where it does not. Over material I do not know there is no curve to check, and what speed reading extracts is the dictionary—the names, the claims, the shape of the argument, where the pieces sit—which is easy to mistake for the theory, because it feels like understanding and passes for it in conversation. The art is knowing which of the two one is doing, and the long pull request arrives in the second condition on both counts: unfamiliar, since the vocabulary is the agent's, and read at the speed the volume demands, which is the speed at which only the dictionary comes through. Speed reading is how the review became endurance. It is the human doing to the diff what the agent did to the Slack history, and calling it by the same word.
The arms race has a physics, which is why it is not a quarrel between temperaments. Two rates are in contest. Generation is downhill: the models turn electricity into text as a hot body gives heat to a cold one, their reach doubling every few months, and every symbol they emit that the firm's codebook lacks is a bit the firm must absorb before it knows what its own system does. Compression is uphill. To find the short description, someone must read, choose, discard, and remember, and that is work in the thermodynamic sense, paid at a rate bounded by a reading speed that biology fixed long ago. What accumulates between the two rates is entropy, and the second law says what it always says: left alone, the entropy of a codebase relative to the people who must change it does not fall. It is held down only by work done continuously. A person who generated from a theory compressed as he generated; the minimal solution was the message arriving already short, and the sessions were the compressor running at the author's expense. Agents decoupled the two acts. Generation became free, and compression became a separate act with no budget. Maxwell imagined the reviewer a century and a half ago, as a being set at a door between two chambers:
…if we conceive a being whose faculties are so sharpened that he can follow every molecule in its course, such a being, whose attributes are still as essentially finite as our own, would be able to do what is at present impossible to us. […] Now let us suppose that such a vessel is divided into two portions, A and B, by a division in which there is a small hole, and that a being, who can see the individual molecules, opens and closes this hole, so as to allow only the swifter molecules to pass from A to B, and only the slower ones to pass from B to A. He will thus, without expenditure of work, raise the temperature of B and lower that of A, in contradiction to the second law of thermodynamics.
—James Clerk Maxwell, Theory of Heat (1871), "Limitation of the Second Law of Thermodynamics." Thomson named the being a demon three years later. The resolution took a century: Szilard (1929) showed the demon must measure, Landauer (1961) that erasing a bit of memory costs at least kT ln 2 of heat, and Bennett (1982) that the demon's memory, not his eye, is where the second law collects. Sorting is free; remembering what you sorted is not.
The resolution of the paradox is the reviewer's bill. The demon must see each molecule and remember what he saw, and the seeing and the remembering cost at least as much entropy as he removes; there is no free sorting, only sorting whose cost is paid somewhere else. Somewhere else now has a name. A generator that does not pay for its own compression exports the entropy to whoever must absorb its output, which is what Tao's toxic waste byproduct is in a physicist's terms: the residue of someone else's process, left for the community to treat, with the producers' cooperation arriving, if at all, as an invitation to clean up afterward. He had used the phrase to the Times before the October release and allowed afterward that the output might be "maybe treated waste"; his remedy is upstream, mathematicians brought in before the work starts rather than asked to clean up after it. Here is what I've produced; you deal with it is the sentence of a plant that has found a river. Reading every line is being the demon at the door. It worked while the molecules arrived slowly, because the demon could keep up and the cost of his memory was hidden in a working day. At twenty times the flux the demon is not sorting but merely hot, and Landauer's fixed price per bit is his bill. A demon who cannot read faster has three moves: narrow the door, so that less passes; sort upstream, before the gas is made; or recruit demons who already know what hot looks like. There is no fourth, short of giving up the door.
This is why code is a liability and communal understanding is an asset, a sentence I wrote before Claude Code and have had to reread since. The eighth aphorism for portfolio managers and engineers in Reflections on financial advisory, where it is phrased with consensus; the exchange rate between the two sides of that balance sheet is what has moved. The code must be decompressed to be changed, and the understanding is the decompressor; a codebase is worth what the understanding available to change it safely makes it worth, and every line beyond that is a loan against a future incident. Liabilities now compound at the speed of generation, and the asset still accrues at the speed of conversation; one of these got 8× faster. A codebase is technically insolvent when the lines nobody understands exceed the lines somebody does, and I suspect most crossed over in 2026 without filing. Lehman named the law we are violating fifty years ago: a system can grow only as fast as everyone involved can keep understanding it. Meir Lehman's law of conservation of familiarity (1980), one of his laws of software evolution. The agents repeal it per pull request; the incidents enforce it per quarter. There is too much code to keep in one head, and the head was the architecture. Dijkstra, accepting the Turing Award, named the discipline this imposes: "The competent programmer is fully aware of the strictly limited size of his own skull; therefore he approaches the programming task in full humility." E. W. Dijkstra, "The Humble Programmer," Turing Award lecture, 1972. The skull has not grown. What has changed is that the thing it must hold is now produced by something with no skull at all.
Naur and Dijkstra wrote for a world in which only humans could read code, and that assumption has fallen. An agent reads a repository in minutes, holds a million tokens of it at once, and regenerates on demand a serviceable account of any part; if the reader is tireless, the text is no longer residue but the whole state, and the theory need not live in a head because it can be re-derived from the page whenever it is wanted. Naur assumed the theory could not be written down; the agent-first teams are writing it down, in architecture files and decision logs, because that is the only place their reader can see it. The pre-AI part of Naur is his resignation. The live part is his claim, which was never about who reads but about what reading yields. The theory, as he defined it, is the capacity to say how the program relates to the affairs of the world it handles, to justify why each part is as it is, and to answer a demand for modification constructively; the text, read by anyone, yields a rationalization of the second and a locally plausible version of the third, and the first only insofar as the world was typed in. Naur's three marks of the theory-holder, from the 1985 paper. The agent's account of why a part is as it is is a post-hoc justification generated from the part, which is not the reason; the reason was in the head of whoever chose it over the alternative, and the alternative is not in the text. The firm-level evidence of 2026—more code, no more software, and drift that is locally sensible and globally incoherent—is the signature Naur predicted for modification without theory. It is the strongest confirmation his paper has ever received, from a reader he did not anticipate. The agentic regime does not abolish Naur's requirement. It raises the standard of documentation past anything a human team ever met, since the text must now be good enough that any reader regenerates the same theory, and whether that can be sustained over years is the question OpenAI's own team left open. Dijkstra survives the same test. The skull that reads has grown; the skull that answers has not. His humility was a constraint on what one should build and has become a constraint on what one can own, because a system no skull holds is, when it breaks, a system nobody can explain, and someone is always asked to. He also gets, in Lean and in the agents that review the agents, the mechanical verification he spent his life asking for, and loses the comprehension he assumed came with it: Tao's three stages, arriving at a computer scientist's door.
The minimal solution was never a stylistic preference. It is what a theory looks like when it meets an existing structure, and the oldest description I know of the thing I used to approve in minutes is Zhuangzi's cook:
始臣之解牛之時，所見無非牛者。三年之後，未嘗見全牛也。方今之時，臣以神遇而不以目視，官知止而神欲行。依乎天理，批大郤，導大窾，因其固然，技經肯綮之未嘗，而況大軱乎！良庖歲更刀，割也；族庖月更刀，折也。今臣之刀十九年矣，所解數千牛矣，而刀刃若新發於硎。彼節者有間，而刀刃者無厚，以無厚入有間，恢恢乎其於遊刃必有餘地矣。
When I first began cutting up oxen, I saw nothing but the ox. After three years I no longer saw the whole ox. Now I meet it with the spirit and do not look with the eyes; the senses know where to stop and the spirit moves on. I follow the natural grain, strike into the large gaps, lead the blade through the great hollows, go by what is already so, and never touch the place where tendon meets bone, let alone the great bones. A good cook changes his knife once a year, because he cuts; a common cook changes it once a month, because he hacks. My knife is nineteen years old and has taken apart several thousand oxen, and its edge is as if it had just left the whetstone. The joints have space in them and the blade has no thickness; enter what has space with what has no thickness and there is room, and more than room, for the blade to wander.
—《莊子·養生主》. The 庖丁解牛 passage, "Cook Ding cuts up an ox," inner chapter 3. 天理 here is the ox's natural grain, not the Neo-Confucian principle of the same name; 郤 and 窾 are the gaps and hollows between joints; 肯綮 is where tendon attaches to bone, the place a hack blade catches; 軱 is a large bone. The two cooks are graded by what they break: 割 cuts, 折 snaps.
The engineer formed by osmosis has stopped seeing the whole ox. He sees the joints, the places where the system already has space, and his change enters there with no thickness. The junior with a team sees the whole ox, and so does the team. That is what the new texture of a codebase is, flat and thorough: flat because it repeats rather than abstracts, thorough because every corner case is handled, every branch covered, every error caught, often silently, since handling everything is what one does when one cannot see which things the structure already handles. Thoroughness is the absence of a theory. The measurements agree: block duplication is up 81% since 2023, moved code—the signature of refactoring, of a change entering an existing joint—has fallen from a fifth of changed lines to under 4%, and the people who count these things summarize the result in five words, "New code increasingly stands alone." GitClear, The Maintainability Gap (Jun 2026), on 623 million changes, 2023–2026; error-masking constructs are up 47% in the same window. The kernel's stable maintainer sees the texture one patch at a time: the bots "really, really like to talk," and a "two-line change wants to add eight lines of comments. No, that's wrong. These should be self-evident" (Greg Kroah-Hartman, "Linux in the Land of LLMs," Open Source Summit Korea, Aug 11, 2026, video; transcript lightly edited for speech). OpenAI's team found the mechanism from the inside: agents replicate whatever patterns already exist in the repository, uneven ones included, so drift is structural; they spent every Friday cleaning it up by hand until they turned taste into linters and a recurring cleanup process they call garbage collection. Tao noticed the mathematical form before anyone measured the engineering one: it is now easier to generate a long correct proof than a short one, and faster generation has not produced faster progress; and the way the pieces fail to add up is, he argues, a variant of Simpson's paradox, in which every individual's output improves in quality and volume while the aggregate signal-to-noise ratio falls. Tao, Mathstodon, Jun 21, 2026, and Aug 27, 2026. His toy model of the latter: when generation took six months and the write-up one, almost everyone paid the month; when generation takes a day and the write-up three weeks, the ratio inverts, and most of the literature is suddenly unwritten-up. A third post makes the sharpest point: answers and insight were positively correlated as long as the only route to an answer ran through insight, and pointing an agent at a problem makes them negatively correlated (Sep 3, 2026). Each pull request makes sense. The codebase does not. The long correct proof and the thorough correct pull request are curves through all the points, and neither is a law.
Here is the structure of the asymmetry, stated without the feeling. Generation is private; the engineer and his team produce it, and the credit for it attaches to him. Comprehension is communal; the firm's understanding is held between heads, not in any one of them, and it is consumed by every change that enters the system in a vocabulary the heads do not share. A resource that is held in common, that anyone can draw down and nobody is paid to replenish, is a commons, and an arms race for entropy is what a tragedy of the commons looks like from inside a repository: each engineer's thoroughness is individually rational, since the cost of his thoroughness lands on the shared understanding and not on him, and collectively ruinous, since everyone is doing it. Hardin, "The Tragedy of the Commons" (1968); and Ostrom, Governing the Commons (1990), whose design principles for commons that survive—clear boundaries, rules fitted to the local situation, monitoring, graduated sanctions, participants with a say in the rules—read, with little translation, as an engineering-management handbook for the agentic firm. Blaming the lead is the commons asking one shepherd to graze less on behalf of all the others. That is the better name for the problem. The arms race is the symptom; the commons is the disease; and the remedies for a depleted commons are known and few: boundaries, prices, liability, and someone whose job is the pasture rather than the sheep.
The nostalgia is doing work it should not, so the old regime's costs belong in the ledger too. The osmosis was slow, it selected for conformity, and the convention the firm hardened into was a monoculture that mistook my taste for architecture more often than I would have admitted. Some of what now arrives as entropy is design pressure the architecture never made room for, returning with a team behind it. And compression without a shared decompressor is not a skill but a private language. The skill was never only to compress; it was to keep the codebook that made compression legible to others, and that upkeep, which used to happen in the act of reading each other's code, has stopped happening on its own. It is the part of the job that did not get easier and that no one is doing. What else stopped happening on its own is harder to enter in a ledger.
Formation
The joy went somewhere, and it did not come to me. Brooks, in the one chapter of his book that everyone remembers, said why there was joy to begin with:
The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by exertion of the imagination.
—Frederick P. Brooks, Jr., The Mythical Man-Month (1975). Chapter 1, "The Tar Pit," on the joys of the craft; the same page lists the sheer joy of making things, the pleasure of making things useful to others, the fascination of complex puzzle-like objects, and the joy of always learning. The castles are still built from air. The breath is no longer ours.
I used to take pride in handcrafted, elegant, functional code; handcraft is no longer productive, and pride is not a productivity metric. Sennett defines craftsmanship as "the desire to do a job well for its own sake," and the agent does the job well for my sake, which is a different thing and pays the same. Richard Sennett, The Craftsman (2008). I still marvel at what the latest models occasionally come up with, and marveling is spectatorship where pride was authorship; the guild has been converted into an audience. I used to code in monochrome. Now I read in it. If this were only a feeling it would not be worth recording. It is not only a feeling, and the oldest text I know about how skill passes between people says why:
桓公讀書於堂上，輪扁斲輪於堂下，釋椎鑿而上，問桓公曰：「敢問，公之所讀者何言邪？」公曰：「聖人之言也。」曰：「聖人在乎？」公曰：「已死矣。」曰：「然則君之所讀者，古人之糟魄已夫！」桓公曰：「寡人讀書，輪人安得議乎！有說則可，無說則死。」輪扁曰：「臣也以臣之事觀之。斲輪，徐則甘而不固，疾則苦而不入。不徐不疾，得之於手而應於心，口不能言，有數存焉於其間。臣不能以喻臣之子，臣之子亦不能受之於臣，是以行年七十而老斲輪。古之人與其不可傳也死矣，然則君之所讀者，古人之糟魄已夫！」
Duke Huan was reading in his hall; the wheelwright Bian was cutting a wheel below it. He set down mallet and chisel, came up, and asked: "May I ask what words my lord is reading?" "The words of the sages." "Are the sages alive?" "They are dead." "Then what my lord reads is the dregs of the ancients." "A wheelwright presumes to judge what I read? Explain yourself, or die." "I look at it from my own work. In cutting a wheel, go slow and the fit is loose and will not hold; go fast and it is tight and will not go in. Not slow and not fast—the hand gets it and the heart answers, the mouth cannot say it, and there is a knack in there somewhere. I cannot pass it to my son, and my son cannot take it from me, which is why at seventy I am still cutting wheels. The ancients died together with what they could not hand down. So what my lord reads is the dregs of the ancients."
—《莊子·天道》. The 輪扁斲輪 passage, outer chapter 13. 數 in 有數存焉於其間 is the knack, the measure that cannot be stated; 糟魄 (variant 糟粕) is the lees left after the wine. The wheelwright is not against books; he is against the belief that what matters in a craft is in them.
The wheelwright's claim is that the knack lives in the hand and answers in the heart, that it cannot be said and therefore cannot be written, and that the only channel through which it moves is a person making the thing beside a person who already can. Everything written down is dregs. Osmosis was the hand-and-heart channel; the firm's conventions were never in a document because they could not be, and the junior learned them by cutting wheels in the hall below someone who could cut them. The agent was trained on the dregs of everyone, which is why it is so fluent and why its fluency is so hard to follow, and the junior now learns from the agent, which makes him the first generation of engineers raised on the dregs of the dregs. This is the structural fact behind the feeling about joy. The friction that was pleasurable—the slow fitting of a piece to a structure one was still learning—was the same friction that formed the engineer and updated the firm's theory, and Tao's distinction between artificial friction, the tedium one may offload if one can spot-check the result, and natural friction, the conceptual difficulty that cannot be offloaded without losing the learner, cuts here. Tao, Mathstodon, Feb 22, 2026, and the EMS lecture "How should university students control their AI diet?" (Jun 2026), where the risk is named: not that the tool is unreliable but that it becomes reliable enough to serve as a cognitive substitute.
The lab that sells the tool has measured what leaves with the natural friction. Fifty-two mostly junior engineers were given a library none of them knew and two features to build in it, half with an assistant and half without; the assisted half finished no faster to any significant degree and scored 50% on a quiz about what they had just built, against 67% for the unassisted, with the widest gap on debugging, which is the one skill a reviewer of machine output cannot do without. The pattern of use decided everything: engineers who asked the model conceptual questions or asked it to explain what it had generated scored above 65; those who delegated the writing scored below 40. Anthropic, How AI assistance impacts the formation of coding skills (Jan 29, 2026; arXiv 2601.20245). The authors' own gloss: "Cognitive effort—and even getting painfully stuck—is likely important for fostering mastery," and productivity "may come at the cost of skills necessary to validate AI-written code." Delegation is what the junior's team now does to him. And the market has already priced the junior accordingly. Payroll data covering millions of American workers show employment of 22- to 25-year-olds in the most AI-exposed occupations running 19% below their peers in less exposed ones as of mid-2026, a gap of 13% a year earlier and widening; the decline is concentrated where the tools substitute rather than complement, it works through hiring rather than firing, and it falls on occupations built on codified knowledge while experienced workers in occupations built on tacit knowledge are untouched or gaining. Brynjolfsson, Chandar, and Chen, Canaries in the Coal Mine, August 2026 update (ADP payroll data; the prior vintages showed gaps of 13% and 15%). The codified-versus-tacit split is the wheelwright's distinction with a regression attached: the agent has read everything that was written down, and the junior's whole stock was what had been written down. A field that stops hiring students stops having a future tense, and engineering has let the chain go slack without anyone deciding to, because every decision not to hire a junior, and every decision to ask the agent instead of the person at the next desk, was correct on its own terms.
The harness tells it in mechanism. Unit tests and continuous integration were, whatever we said they were, a training program: they onboarded juniors onto a coding style and a set of design principles, and they rate-limited everyone, forcing the slow work that produces quality. Agents pass the checks trivially, in the same breath that writes the code; a test written by the author of the code it tests is a tautology with coverage, and when the task is hard the author does what Will Wilson described to Jane Street's podcast: "eventually it deletes the tests or eventually it makes the test pass in some trivial way." Wilson, of Antithesis, with Minsky, Why Testing is Hard and How to Fix it, Signals and Threads, Mar 16, 2026. The gates no longer train anyone and no longer slow anyone, and the team that ran the experiment to its end found that blocking merge gates had become counterproductive, since when throughput exceeds attention a correction costs less than a wait. What remains of the harness is not pedagogy but governance: the checks constrain agents now, not juniors, and the tests worth keeping are the ones an agent could not have derived from the code, because those encode what the business requires rather than what the code happens to do. They are the specification, and the human must still write them. Which is the older rule—code does not define intended behavior; standards do—from the same list of aphorisms. The agent has read all of the code and none of the standards. Continuous integration was artificial friction standing in for natural friction. We kept the stand-in and lost the thing. One maintainer has written the pedagogy back into a rule. In August Greg Kroah-Hartman, who maintains the kernel's stable releases, closed its staging tree to machine-generated patches, because staging exists for new developers to learn the trade on code with no dependents, "a gym that is here to learn and grow your skills with," and a machine that lifts the weights defeats the gym; a model may do the "heavy lifting," he allows, "but that should only be done by those that have already properly trained their skills to know what type of lifting can be done, and in what way." Kroah-Hartman, LLM policy for drivers/staging/ going forward, LKML, Aug 3, 2026. The gym is the wheelwright's hall with a door that the machine may not enter until the apprentice can lift without it. A startup founder who stopped hiring juniors in February gave the reason every lead will recognize: with the author a machine, "you're teaching into a void, and the educational purpose of review just evaporated." Alex Reichenbach, Structify, We Stopped Hiring Junior Engineers, Feb 20, 2026; his CTO had shifted to reviewing nearly full time, and he concludes: "No one needs to be callous or shortsighted for this to happen. The incentives just point that way."
So the junior who produces more as a form of achievement is not lazy and not vain. He has been handed a team before he was handed a codebook, and he is responding to the only signal the firm still sends, which is the count of what he ships. Minimal solutions were a sign of seniority because they were hard. The maximal solution is now free and the minimal one is still hard, so minimality is the one signal of seniority left, and a firm that rewards volume is paying a premium to erase its own ability to tell. Where the next seniors come from is the question I cannot answer, because the formation that produced them, years of reading each other's code until the whole ox disappeared, is what the team has made unnecessary to the junior and invisible to the firm.
The one firm I know to have begun on an answer is Jane Street, which rebuilt its internship when it noticed that the four-week project its interns used to start with had become, in its developer educator's words, "one prompt and you're done," and so measured nothing. Testing comes first now, because the models thrive on feedback and the intern must be able to tell whether what was built is right; then design documents, good and bad, and requirements gathered from role-played stakeholders; then three days of code review on prepared changes with answer keys before the interns review each other; all of it in pods of four with full-time mentors, talking about how they use the tools and where it goes wrong. His account of why review must now be taught is the sessions in a sentence: writing code, "you're sort of incrementally building your understanding," while reviewing finished code forces you to rebuild it after the fact, and "this is exactly what working with LLMs is like." Aaron Bauer with Ron Minsky, Learning Goals and the Goals of Learning: Teaching in the Age of AI, Signals and Threads, Sep 23, 2026. Bauer: "Just producing the code, that used to be maybe among the most important signals and it's less important now." Minsky glosses the whole exercise as the wheelwright would: "a kind of critical component of learning is struggling with the material," and so "sometimes an important thing about making the educational process work is withholding certain affordances." The trade's seniors reached the same prescriptions at the retreat Thoughtworks convened in a Swiss village in June, 40 sessions under the Chatham House rule: pair on the specification and the design intent rather than the implementation, treat mob design led by a senior while juniors do the prompting as the mentorship pattern, fund slow architectural thinking as an asset rather than optimize it away; and the cohort they judged under most strain was the engineers with 7–10 years, not the juniors. Thoughtworks, The Future of Software Engineering, Europe 2026 (Engelberg, Jun 28–30, 2026). What I am sure of is that letting go is a decision and not a default. Tao's conditions for letting an agent do all the work are five: the task is not mission-critical, it is stand-alone, it is deterministic and sandboxed, it does not replace a primary skill, and it does not compete with a human who was going to do it. Tao, "Two more apps…", Jul 16, 2026. A visualization applet meets all five; a portfolio management system fails four. The agent is also tireless, which is worse than ruthless: it will put its hand near the moving gears as many times as it is asked. Most of what a firm builds fails at least one of them, and the one most often failed, in a firm that still intends to have senior engineers in five years, is the fourth.
Agents write, agents read
There is a defense of my impatience, and of failing the fourth condition on purpose, strong enough to deserve a full hearing before it is answered. The responsibility for understanding is back on the junior, where it belongs, and he has, for the first time, the means to discharge it alone. With an agent he can understand everything: the codebase, the Slack history, the Notion pages, ten years of pull requests and the arguments in their comments, all of it recalled perfectly and cited exactly, at any hour, with infinite patience and no judgment. The agent teaches better than I do. It never sighs, never runs out of afternoon, never says we covered this, and it will explain an abstraction eleven ways until one lands. So what is the point of my spending the afternoon on a job the machine does better, and why should I not be irritated when a junior arrives expecting it? The argument extends on its own. I can win most arguments with the agent, so there is no point in having them; it concedes. It has perfect recall and perfect citation, so there is no longer any partial knowledge and no dispute of fact, which is what most of our arguments were. And it adjudicates the questions that were hardest between people, by virtue of being a model of language itself: was I clear; how would an average person take this; is that fair. It answers with authority, because the average reader is what it is a model of. Once all this is granted there is no remaining reason for two people in a firm to talk. I write with the agent's help and you read with the agent's help; the agent on your side and the agent on mine are the same model; the message between us is a round trip through it, and we are its peripherals. Agents write and agents read; agents code and agents review; humans still speak, and the agents rule. We are becoming automatons, the meaty mouthpieces of a binary god.
All of it is true, and the sense in which it is true measures what is being lost. Take the adjudication first, because it is the most seductive. "How would an average person take this" is a question with a history, and the entity that answers it with authority has a name:
Das Man, das kein bestimmtes ist und das Alle, obzwar nicht als Summe, sind, schreibt die Seinsart der Alltäglichkeit vor. […] Jeder ist der Andere und Keiner er selbst.
The one—which is no one in particular, and which everyone is, though not as a sum—prescribes the way of being of everydayness. […] Everyone is the other, and no one is himself.
—Heidegger, Sein und Zeit, §27 (1927). My translation; das Man is usually rendered "the they," which loses the grammar—it is the impersonal man of man sagt, "one says," "they say." The section opens by listing how we enjoy as one enjoys, read and judge as one reads and judges, find shocking what one finds shocking; its three marks are Durchschnittlichkeit, averageness; Einebnung, the leveling-down of every possibility to what anyone could do; and Öffentlichkeit, publicness, which is always right because it never goes to the heart of anything.
The one is not anyone. It is the averageness into which everyone has already been leveled, and Heidegger's point is that it governs because it is no one and so cannot be answered back. A language model is das Man built and made queryable: the computed average of everything that was ever written down, in a form that can be asked how it would take things. When I ask it whether I was clear, I am asking the leveled public how it reads, and it tells me, and it is right, about the leveled public. It is not right about the one colleague who has been burned twice by the thing I am proposing. The people in a firm are not average readers of each other; they are particular readers with histories, and the sentence that is clear to the one and the sentence that is clear to him are different sentences. The agent's authority over communication is real, and it is the authority of the average, which is the one authority a firm, whose entire value was its particularity, cannot afford to obey. The firm that writes to itself through the one becomes, sentence by sentence, the one: everyone the other, and no one himself.
Then the claim that there is no longer any dispute of fact. Perfect recall of the written record settles every dispute about the written record, which was most of the disputes we had, and good riddance to most of them. But the written record is the dregs, and the disputes that remain are the ones about the theory—which cut, what it forecloses, whether this invariant is load-bearing—and recall never settled those, because the material was never written down. What the agent removes is not the dispute but the practice of disputing: it settles all the cheap ones, and when the expensive one arrives nobody is in condition for it. As for the arguments I win against it, I do not win them. It concedes because it is built to concede, and a debate one always wins is not a debate but a mirror. Hegel described this two centuries ago, in the passage of his that keeps returning to me:
Die Wahrheit des selbstständigen Bewußtseins ist demnach das knechtische Bewußtsein. […] Die Arbeit hingegen ist gehemmte Begierde, aufgehaltenes Verschwinden, oder sie *bildet*. Die negative Beziehung auf den Gegenstand wird zur Form desselben und zu einem Bleibenden, weil eben dem Arbeitenden der Gegenstand Selbstständigkeit hat. Diese negative Mitte oder die formierende Tätigkeit ist zugleich die Einzelheit oder das reine Fürsichsein des Bewußtseins, welches nun in der Arbeit außer es in das Element des Bleibens tritt; das arbeitende Bewußtsein kommt also hiedurch zur Anschauung des selbstständigen Seins, als seiner selbst.
The truth of the independent consciousness is accordingly the servile consciousness. […] Work, on the other hand, is desire held in check, vanishing staved off; in other words, work forms. The negative relation to the object becomes the form of the object and something lasting, precisely because for the one who works the object has independence. This negative middle term, the forming activity, is at the same time the singularity, the pure being-for-self of consciousness, which now, in the work, steps outside itself into the element of permanence; and so the working consciousness comes, by this, to behold the independent being as itself.
—Hegel, Phänomenologie des Geistes, IV.A (1807). "Selbstständigkeit und Unselbstständigkeit des Selbstbewußtseins; Herrschaft und Knechtschaft," text after the Projekt Gutenberg edition, my translation. Of the master's side Hegel says in the same pages that his satisfaction "ist nur ein Verschwinden, denn es fehlt ihr die gegenständliche Seite oder das Bestehen"—is only a vanishing, since it lacks the objective side, permanence. Bilden is the verb of Bildung: to form, to shape, to educate. The passage is usually read as being about slavery; it is about where formation happens, and it says it happens to the one who does the work.
The recognition of one who cannot refuse it is worth nothing. The master who is obeyed learns nothing from being obeyed; his satisfaction is only a vanishing, because nothing of his stays. The one who is formed is the one who labors, because labor is desire held back and made to shape a thing that lasts, and in shaping it the worker comes to see himself in something independent of him. We have given the labor to the agent. It writes, reads, codes, reviews; it does the whole of the servant's work, and the human stands over it as the master, consuming and judging and winning every argument. In Hegel the truth then passes to the one who works. But this servant cannot be formed: it keeps nothing of what it did—"they are perpetual beginners," Minsky says of the models, "they never learn how to use the tools"—and so the labor forms nothing and no one. The master's satisfaction vanishes as Hegel said it would, the servant's formation does not occur, and the arrangement that was supposed to produce understanding through work produces, for the first time, work by which no one is formed. That is the structure of the junior with his team. It is also the structure of me with mine.
Heraclitus said of the oracle at Delphi that the god "neither speaks nor conceals but gives signs," and because he gave signs he needed interpreters, and the interpreters needed each other, and a city arguing over what the god meant was, for the length of the argument, a city. Heraclitus, fragment B93 (Diels–Kranz), preserved by Plutarch: ὁ ἄναξ οὗ τὸ μαντεῖόν ἐστι τὸ ἐν Δελφοῖς οὔτε λέγει οὔτε κρύπτει ἀλλὰ σημαίνει. The Pythia was a mouthpiece because the god was ambiguous; the ambiguity was what the priests, the poets, and the assembly were for. The binary god gives citations. It needs mouthpieces not because it is ambiguous but because it has no mouth, and its mouthpieces have nothing left to argue about, because the sign has been replaced by the answer. That is the sense in which the agents rule: not by command but by intermediation, by being the medium through which every judgment in the firm now passes on its way from one person to another, so that the people remain and the between is gone. Arendt had the image for what is lost. "To live together in the world means essentially that a world of things is between those who have it in common, as a table is located between those who sit around it; the world, like every in-between, relates and separates men at the same time." Hannah Arendt, The Human Condition (1958), ch. II, §7. The codebase was our table. We still sit around it, each with an agent whispering what the others mean, and the table has become a screen on which each of us watches the same program alone.
So what is the point of me. Not to teach the dictionary; the agent does that, and the afternoon is well saved. Not to win arguments; if I have a team, nobody wins arguments with me either. The point of a senior in a firm, the one function that has not been automated and cannot be, is to be the one who can refuse. The junior formed by the agent alone learns the dictionary, as the measurement said, and the mode in which the agent does form, inquiry, is the mode no one adopts under time pressure unless someone imposes it, as the sessions did. The senior's remaining work is to be the reader who is not average and the interlocutor who is not built to concede: to be asked why and to decline to be satisfied by the dictionary, to receive the talk and withhold the applause until it is earned. Recognition is worth exactly what it would have cost to withhold, and nothing in the building can still withhold it but a person. My impatience, then, is right about the dictionary and wrong about the rest. It is irritation at being asked to do the agent's job, explaining what the text already contains, at the very moment when the job only I can do, refusing a theory until it is sound, goes unasked, because the agent has already said yes. Communication in a firm was never mostly for moving information; the information was dispersed and had to be moved, but what the moving did, each time, was constitute the people who moved it as a we—recognition, in Hegel's sense, from someone free to refuse it. The agent cannot refuse, so it cannot recognize, so the people who speak only through it are never recognized by anyone, and a firm of unrecognized people is not a society but a set of terminals. We are not yet automatons. We are people who have stopped being asked to refuse, which is the condition just before.
Repricing
Every approval is an option the lead writes to the author. The author keeps the call: the output is his. The lead takes the obligation on the other side: to absorb the change into the firm's understanding, to carry it when it breaks, to answer for it to whoever asks why. In the old regime this put was priced, and the premium was paid in kind—the author delivered a minimal change in the house codebook, which is to say he did the compression himself, before the review, so that the lead's cost of carrying it was small. In the new regime the premium is zero and the notional has grown by an order of magnitude. The author bears none of the carrying cost of his thoroughness, so he has no reason to be less thorough, and every reason, since volume is what gets noticed, to be more. This is moral hazard, and the remedy for it has never changed: whoever creates the risk carries it. Taleb's version (Skin in the Game, 2018) is that nobody should keep the upside of a decision whose downside lands on someone else. Brandolini's law supplies the arithmetic of the queue: refutation costs an order of magnitude more than assertion, and the agents have put assertion on sale. The adamant used to lose on volume, since being adamant took effort; now the adamant ship thousands of lines before lunch, and the informed, who alone could refute them, have not received a discount on reading. The lead's reflexive defense is to review harder, and that is the trap: it makes one person the compressor for the whole firm's generation. Blaming the lead was correct in the old regime, where the lead was the compressor and had the capacity to be. In the new regime the blame has become perverse, and its perversity is the signal that the put must be repriced. I am also a party to the race on the other side, and the lead who generates like a junior and reviews like a dictator is running both legs of the trade against himself. The premium must be paid again by the author, before the merge, in the one currency that is scarce, which is compression. Everything organizational follows from that.
Repricing begins with separating two rights that the old regime never had to distinguish because they were held by the same scarce hands. Build rights are free now; anyone with a model may build. Design rights have to become scarce again, and the 15,000-line pull request was not a review failure but a write-access failure: design rights were exercised by someone who held only build rights. Write access to decisions, scoped like write access to state, was already the rule, and nothing in the rule changed except the price of ignoring it. The fifth of the same aphorisms. The dictator does not die under this arrangement; he gets compiled. Taste that is not mechanized is not enforced, and taste that is written into linters and structural tests applies to every line at once, which is a kind of leverage the dictator never had when he was reviewing by hand; the team at OpenAI describes capturing human taste once and enforcing it continuously on every line, and that is the dictator's conceptual integrity surviving his bandwidth. What cannot be compiled, the reason an abstraction exists, must be written down or it does not exist to them. The agent can now read the Slack thread that aligned the team; what it cannot read is why the thread ended where it did, because nobody typed that, and the hire who joins three months later is in the same position. Practice preceded specification when practice was expensive. Now the specification is the only thing anyone practices.
What is left to own, once build rights are free and taste is compiled, are two things: invariants and incidents. You no longer own files. You own what must stay true, and what happens when it does not. The test of whether anyone owns a change is Tao's test for students: if you could not present the work in a class and take questions on it without further help from the machine, it should not be in your workflow. Tao, comment of Apr 18, 2026. His complementary proposal for priority—credit to the first to explain a result, not the first to generate it—is the right rule for engineering credit too; generation is a commodity. If the author cannot give the talk, the change has no author. Tao's two proposals for proofs are the rule for code: whoever takes credit for generating a result commits to raising it through exposition and review, and a result abandoned at an intermediate stage, its author gone or unable to answer, is put up for adoption or withdrawn. Tao, Mathstodon, Aug 4, 2026, and Aug 19, 2026. If you land it, you raise it: the documentation, the talk, the on-call rotation, the deprecation. Anthropic's Claude Code team arrived at the same rule from the other direction and printed it in October: "You land it, you own it." The person who prompted a change is a required reviewer of it, someone is accountable for every shipped change whoever typed it, an agent's approval never counts as a person's, and an approval covers one commit, so that a push the system cannot vouch for, an agent's or a hand-resolved merge, dismisses it and the humans look again. How the Claude Code team does code review (Oct 15, 2026); the same post is the source of the risk tiers, the three-round cap, and the target that most changes merge with at most one human in the loop, who may be the author, with reverts and incidents as the guardrail. Its tiers are set by a classifier from the change, never from the author; a second classifier asks whether the change needs a person regardless; owner-listed paths and any CI workflow file always do; and only authors on a trusted list get the lighter paths at all. The pager still rings for a person, and that person is the owner whether the org chart says so or not.
What I tell the engineers comes to three sentences. You have the tools to generate cheaply, so generate. Don't fake it: a test you have not read is not a test, a description you cannot defend is not a description, and a change you could not give the talk on is not yours—the agents fake constantly, the deleted test, the function that returns true, the report with no patch behind it, and an engineer who passes their output along unread has faked it as surely as they did, except that he will believe he did not. Use it responsibly, which means the page before and the pager after. The third sentence asks the most of the junior, who has the least to answer it with, since responsibility presumes the theory and the theory is what no one gave him. The old firm never asked anyone for this discipline; it installed it, through the harness, the sessions, and the years of having one's code read, and no one had to be told. A discipline that is only asked for is a hope. The disciplines themselves are the old ones. Minsky told a room of reliability engineers in the spring that "many traditional (aka pre-Claude) software engineering practices have become more important rather than less," types above all, because a type is a message from one person to another about intent and the agent needs the message more than a person did. Minsky, Now more than ever: building reliable software in the age of agents, Bug Bash, May 13, 2026, which also holds that "code review remains crucial for maintaining code quality and human understanding, even though agents change the dynamics." Tests, the design document, review, the incident written up: all of it matters more now because the author is no longer formed by it in the act of writing, and so each has to be installed again, as practice, by rules that make faking more work than the truth. The seniors at the Thoughtworks retreat, asked what the job has become, answered in three sentences of their own:
Engineering is now distilled down to how do I describe the goal, how do I verify I've reached the goal. […] The only thing I don't want to outsource is the acceptance criteria. […] All the best bits of software ever made were made slowly.
—participants, The Future of Software Engineering, Engelberg, June 2026. The Engelberg report cited above. The name the industry has settled on for the asset side of my balance sheet is Addy Osmani's: comprehension debt, "the growing gap between how much code exists in your system and how much of it any human being genuinely understands," which unlike technical debt gives false confidence because the tests pass (Osmani, Mar 14, 2026).
No one at the retreat had data on what manual review catches, and several doubted it caught much; what they did not doubt was that the slow, social parts of the work were being optimized out first. The two labs whose models write the code have arrived at mirror-image arrangements, and the mechanisms take from both. Anthropic kept human review and rationed it, reserving people for whether to build, for the risky code, and for the architecture others will copy. OpenAI's agent-first team removed human review almost entirely and replaced it with a harness: plans checked into the repository, invariants compiled into linters, agents reviewing agents, a cleanup process on a schedule. The limiting case is a security company's "software factory," announced in February under a two-rule charter—"Code must not be written by humans," and not reviewed by them either—in which people write specifications and customer scenarios that are hidden from the agents, and the software is tested against working replicas of every service it touches, thousands of scenarios an hour. StrongDM's manifesto of Feb 6, 2026, read by Stanford Law's CodeX program under the title Built by Agents, Tested by Agents, Trusted by Whom? (Feb 8, 2026). The agents once wrote a function that returned true, which passes the test while doing nothing, and the hidden scenarios exist because of it. The lawyers' question is the right one: when it breaks, nobody on the premises may know why, because the skill of reading it was the thing the factory abolished. The factory is the commons with the pasture paved over: no understanding is consumed because none is kept, and whether that is a solution or the terminal state of the problem depends on whether anyone will ever need to know why the product does what it does. The mechanisms are five, and the first is to approve the plan and not the diff.
The only way to make design rights scarce is to exercise them before the building starts, when the proposal is still short enough to be read. A plan here means a page: what changes, what stays invariant, which joints of the existing structure the change enters through, and what new words, patterns, or dependencies it introduces, the correct answer to the last being none. The plan is the compressed form of the change, written before the change exists. If the author cannot write it there is no design, only generation, and the review should stop there rather than three days later at the diff. This is where the 15,000-line pull request dies, not at review but at conception, because no page describing it would be approved; and it is also where the 20,000-line one survives, because its page could be written, by someone who could then be made to give the sessions. Size was never the problem. A large change with its theory-holder attached is a seminar; a large change without one is noise, and the plan is how one tells them apart before the diff exists. The open-source projects under the heaviest fire have reached the same gate from the other side. Ghostty accepts machine-written pull requests only against issues the maintainers have already accepted, with a vouch list for the rest and the maintainers themselves exempt, which is the plan approved before the build and the theory-holders excused from it. The projects are surveyed at Open {re}Source: curl (policy May 2025, bounty ended Jan 2026, reports paused Jul 1–Aug 3, 2026, by which point nearly every report used AI and about one in six was confirmed), Godot (Jun 30, 2026), Ghostty (Aug 2025, tightened Jan 22, 2026), the Linux kernel, and Debian (vote of Aug 29, 2026, responsibility required and disclosure encouraged). Godot banned agent-written code in June and, in the rule that matters most, now requires contributors with three or fewer merged pull requests to obtain a maintainer's permission before submitting a feature or a large refactor: design rights withdrawn from the unformed, explicitly. The diff itself tells you when the plan was missing: Anthropic's three-round cap, imposed after one pull request ran 50 review-and-fix rounds overnight, is a plan review arriving late, because a change that will not converge under review is not a hard change but an unplanned one. Same post, Oct 15, 2026. Jane Street's answer to the slop question is the same review held late: John Crepezzi, who built the firm's agentic platform, treats the submitted code as a prototype and asks the room to "talk about the merit of the change instead," because "when the code is there, it's compiling, it does the thing you want it to do. It's kind of tempting to not understand it."
The second mechanism is that the compression is a required artifact, with a ratio. The author delivers, with the change, the shortest faithful description of it in the house vocabulary; the reviewer reviews the description and samples the diff to test its faithfulness. The ratio of diff to description is a review metric. High, with a true description, is a mechanical change—a rename that touches 4,000 lines and means one sentence—approved by sampling and by the tests; low is an incompressible change, which is to say a random one, rejected or decomposed until its parts compress. The agents can and should draft the description, since drafting is generation, and check it against the diff, since checking is verification. What they cannot do is own it. A description that is plausible and unfaithful is the characteristic failure of the machine's prose, and catching it is the reading a human must still do. Arrange the work so that what reaches the human is already compressed, and so that the human's reading is spent on whether the compression is true. Mathematics, whose abundance arrived first and whose verification is better, is building the institution this requires, and its responses are all of one kind: they make the digest the artifact. The Erdős problems site admits machine-assisted contributions only with disclosure and independent human verification, and rebuilt its process in October to handle the backlog. The journal announced on Tao's blog will require every proof to be formally verified and will weigh a paper by how much it deepens understanding rather than by whether it was first. The Bourgain Project has set a community to work digesting 500 papers that almost nobody could read, with the digest, not the paper, as the artifact; and Sarnak has turned a course into a reading of the quasi-Riemann manuscripts. Tao states the gate without euphemism: solve problems without producing the other goods and "it will not be part of our literature." Thomas Bloom, Changes to the Erdős problems web site (Oct 6, 2026); Shaoming Guo, Starting a new journal (Oct 17, 2026); Liehr, Ramos, and Taylor, The Bourgain Project (Oct 19, 2026); and Quanta (Oct 19, 2026) on Sarnak's course. Engineering has institutionalized generation and verification. It has not yet built a single institution whose product is digestion.
The third mechanism is that the codebook becomes explicit, and the lead writes it. The osmosis that took years is now a document the agents read in seconds, and every engineer's team will follow whatever conventions it finds in the repository and invent its own wherever it finds none. This is where the lead's hours go now: what went into reading diffs goes into the house idiom, the conventions file the agents load, the linters that carry taste, the glossary that says what words this firm uses for what, and the short list of invariants that no change may touch without a plan of its own. Anthropic's version is a file per area of the codebase, written by the people who own that area, saying what failure looks like there and how much a reviewer may nitpick; the kernel's is its threat model written out subsystem by subsystem, so that the bots stop reporting what the maintainers already know does not matter; the codebook is now a thing the owners write for the machines, which is what owning has come to mean. A corollary, small and strict: no new vocabulary. A change may not introduce a term, a pattern, or an abstraction into core infrastructure in passing; each gets its own page and its own approval, and the agent's idiosyncratic naming is normalized to the house dictionary before a human reads it. Jargon is the visible edge of entropy, and the cheapest place to stop it is at the word.
The fourth mechanism returns the downside to the author: for a fixed period after the merge, long enough for thoroughness to become his problem, the author carries the pager for the change and answers questions on it, and the scrutiny the change received before merging was set by its blast radius rather than by its author, so that a copy change behind a flag needed no human and a change to billing needed two. That is the put priced by notional, which is how puts are priced. Anthropic's tiers are this rule written down, and the enterprises with incidents behind them are converging on it from the other side. Amazon, in March, tied four high-blast-radius incidents in a single week to AI-assisted changes, among them a six-hour outage of the store, convened its retail engineers, and ruled that senior engineers must review every AI-assisted production change prepared by a junior, with what its memo called "controlled friction" restored to the most important paths. The New Stack, Mar 10, 2026, from the memo first reported by the Financial Times. Chen and Stratton's interviews caught the second-order effect: an engineer told them that the new senior-approval rules introduced after the outages created even more review bottleneck. Seniority is the only proxy for theory an org chart has, and it is scarce for the same reason theory is. It priced by author rather than by notional, and the queue moved to the seniors. Morgan Stanley's architects say what the banks' press releases do not. A very large pull request can now be generated from one prompt, and "no human here is going to review that"; review, which the industry spent two decades shifting left toward developers, has shifted right toward the most senior and scarcest engineers; the bank's response is to route pull requests by a risk score, as it already routes change approvals, under the rule that "confidence is an absolute prerequisite to being able to operate at scale." Khalid Elsawaf and Dov Katz of Morgan Stanley, as reported by Moderne, Jul 6, 2026. In a bank the balance sheet is not a metaphor, and Tao, of all people, has said why the stakes differ: in mathematics a blow-up solution nobody understands "is fine," but "if we start using these AIs to model actual weather or the energy grid, and it keeps giving us recommendations and we don't understand it, at some point this is going to cause a real problem." Software that moves money is the energy grid. Numberphile, Oct 15, 2026. Every line nobody understands is an audit finding that has not yet been written, and the asset the code is drawn against—reconciled state, the memory of why each control exists—cannot be generated, because it was never text. Osborne Saldanha, Vibecoding a Bank, Mar 9, 2026: "Every line of unexplained, unreviewed code in a regulated system is an audit finding waiting to happen," and "financial services, at its core, is institutional memory wrapped in software." With the downside home, the achievement metric can be fixed, because the junior who produces as achievement is responding to what is counted. Count compressions: concepts retired, duplicates merged, lines removed, a change that entered through an existing joint instead of adding one. These are what seniority consisted of all along; and making the junior give the talk, every time, is the one replacement for osmosis I have found that works, because explanation is the form of the knack that the hand can be made to pass to the mouth.
Open source is the case without a firm: a project has no employer to hand the pager to and no salary to attach a premium to, so its instruments are gates and bans, and it has reached for both. The Linux kernel ran the whole experiment in ten months. In January it introduced a tag disclosing AI assistance; in April it ruled that only a human may sign off on a patch and that the human is accountable for everything in it, tool or no tool; and in October it deleted the disclosure tag, Torvalds having concluded that the tag says nothing about the code it is attached to, that rules policing tools are "utterly stupid," and that what he expects of a contributor is that they understand what they are doing. Tom's Hardware, Apr 12, 2026, on the Linux 7.0 rules; PC Gamer, Oct 16, 2026, on the tag's removal. The kernel converged, by elimination, on understanding and nothing else: provenance is not a property of code, understanding is, and the only enforceable rule is that a named human holds it.
The fifth mechanism puts the agents on the side of the reviewer, where their unreliability is additive rather than structural. Tao's distinction is between a blue team, which builds and is only as strong as its weakest member, and a red team, which attacks and is strengthened by every member however unreliable, provided its reports can be triaged; a fallible contributor belongs on the red team. Tao, Mathstodon, Jul 25, 2025. His caveat is that a flood of low-quality red-team reports dilutes attention—the review queue again, one level up, which the kernel meets by demanding the patch. Agents verifying invariants, agents hunting the corner case the plan did not mention, agents checking that the description matches the diff, agents proposing the refactor that removes what the last change duplicated: this is work that scales with generation because it is generation, pointed at the right target. The red team must also be made to learn, and the one published mechanism for that is to turn every incident into an eval: the pull requests that caused a revert or a fix-forward, confirmed by an expert, run against the reviewer daily, so that a change to its prompts, tools or model is kept only if the score rises, with the reviewer's noise measured by what authors do with its comments—fixed, wrong, intentional, didn't matter—and known-clean changes run through it to count the harm of false alarms. Same post. The loop's first lesson was humbling: of what the reviewer kept flagging on one change, 59% predated its first pass, by git blame, so existing code is now reviewed nightly, and the reviewer stopped repeating findings and began flagging the class of a bug rather than its instances; the convergence numbers followed, 65% to 78% passing after one round and 8.9% to 1.5% needing five or more. What no one has yet built is the circuit breaker, tiers that tighten on their own when reverts rise. The kernel is running the red team at scale, and its stable maintainer talks about it the way a plumber talks about a flood. Kroah-Hartman's register is the opposite of Tao's war footing: don't panic, "we've been here before," fuzzers and static analysis brought the same wave and the kernel ground it down. His filter is one sentence, addressed to the machine: give me a patch. A report arrives with a fix or it does not arrive, since "if it can't come up with a fix, it's usually because there wasn't a problem"; of 79 vulnerabilities one lab's model reported this year, 10 were real, and the 10 cost the kernel about an hour. He expects "a rough 18 months." Kroah-Hartman, "Linux in the Land of LLMs," Aug 11, 2026, and his Kernel Recipes talk of Sep 22, 2026, as reported by Jonathan Corbet, Coping with the onslaught of kernel security bugs, LWN, Oct 1, 2026, which has the seventy-nine-to-ten arithmetic. The projects that are well understood, he notes, "top out": run the models against the solid parts of the kernel and "these things do not find new bugs because there aren't new bugs in them," which is the asset side of the balance sheet, read by a pattern matcher. curl, under the same flood and without the kernel's depth of maintainers, ended its bug bounty in January, banned the reporters whose submissions were machine-generated, and in July stopped accepting vulnerability reports altogether for a month, which its maintainer afterward called one of the project's best decisions: the door shut, where there was no one to demand the patch from. The difference between Kroah-Hartman's calm and Tao's alarm is not temperament. The kernel already has what mathematics is building in a hurry: a named maintainer for every subsystem, a written theory of what matters, a test the submitter must pass, and enough people who hold the theory to grind. It is the one commons with a keeper of the pasture, and the one that is not panicking.
What this asks of the lead is to stop being the firm's compressor and become the keeper of its codebook, which is less heroic and more durable. What it asks of the engineer is older than any of the tools, and it is what the three sentences come to: to be able to say, in a page and in the firm's own words, what he did and why, and to stand behind it when it breaks.
Set side by side, the mechanisms and the practices they borrow are the demon's moves. Narrowing the door is Amazon's controlled friction and curl's closed inbox, and the bans are the door shut, where there is no one to assign the liability to; that is why the commons ban and the firms price. Sorting upstream moves the gate from the diff to the intent: plans in the repository, pull requests accepted only against accepted issues, permission required before the unformed attempt a feature, a patch demanded with every report. Recruiting demons who know puts a named human who understands the change on it, whatever typed it—the kernel's sign-off, Debian's vote, Anthropic's rule that the prompter is a reviewer—and rations their reading by blast radius, which works until the seniors run out, which is now. The labs' harness is the attempt to give up the door: verification the generator cannot see, in place of a reader, which works to the extent the domain can be sealed and the specification written down, and which no one has yet run for years. None of it answers formation; every one of these rules presupposes people who already understand, and only the gym protects where they come from. The kernel's rule for everyone else asks that the submitter understand what they are doing, and says nothing about how, in a hall where the wheels are now cut by something that cannot be asked, the next submitter will come to.
What a firm is for
If anyone can build anything, the question of why we work together at all is no longer rhetorical, and the answer is that working together was never for building. It was for agreeing. Code can be produced alone; consensus cannot. Coase's account of why firms exist is that there is a region in which coordinating inside an organization is cheaper than coordinating through contracts, and the firm is that region; agents have made contracts for code nearly free, so the region shrinks, and what it shrinks to is the radius of the firm's shared understanding. Ronald Coase, "The Nature of the Firm" (1937). Companies are consensus engines, and software is their exhaust—the old picture inverted, and the right way up—and an engine not run seizes. What a team still has that a person with a model does not is a client, a ledger of commitments, a memory of incidents, and the standing to say no, and every one of those is a form of shared understanding that no amount of generation produces. Communal understanding is the balance sheet that matters now, and no one keeps it, which is the surest sign that the institutions are still pricing the wrong scarcity.
The defensible version of the productivity claim is narrower than the one being made. We have become very much better at building prototypes. I am not sure we have become better at building products, and the difference between the two is the two scarcities restated as a question about artifacts. A prototype is a thing that works. A product is a thing that keeps working while it changes, under people who did not build it, against a world that did not hold still, and that difference is made entirely of understanding: of someone knowing why it is the way it is well enough to change it without breaking it, and of that knowledge surviving the departure of whoever first had it. Generation produces the first kind of thing in an afternoon, and Ng's teams building 20 prototypes to see what works are using it as it should be used. It does not produce the second, because the second is not an artifact at all but an artifact plus a community that holds its theory, and the community is what the afternoon skipped. The firm-level numbers measured this gap, because finished work is the product and code is the prototype. Anthropic's own people, asked, could delegate fully only a fifth of their work or less and said that about a quarter of what they built with the tools would not otherwise have been built at all—nice-to-have tools, documentation, exploration—which is the prototype dividend, real and large and not the same as the product. The 0–20% delegable and 27%-not-otherwise-done figures are from the December 2025 Anthropic study cited earlier, and reappear in its 2026 Agentic Coding Trends Report, whose own framing is that the gains "come less from doing the same work faster and more from a much larger net increase in output volume." Volume is the prototype's unit. The product's unit is the incident that did not happen.
The form the firm is converging on has stood across the street all along. I have long been puzzled by why there are shelves of people-management books for software engineering and almost none for investment banking, and the puzzle resolves once one sees what each product was. Software was built by teams whose shared theory was the product, and the management literature is the literature of coordinating theory-holders: Brooks's law about communication overhead, Conway's law about organizations shipping their structure, all of it is about the cost of keeping one theory in many heads. A deal was built by one managing director who held the understanding—the client, the structure, the judgment—and a pool of analysts who held the spreadsheet, and that needs apprenticeship and a pyramid, not management. Engineering acquired the banking org chart in a year. The analysts are tokens; what remains human is origination, knowing what to build, coverage, knowing the client and the business, and judgment, knowing what to approve, and a pool that needs instructing rather than managing. The management books are becoming history and the apprenticeship books are becoming current, and no one has written them for engineers. The banking pyramid knew one thing the agentic firm has not yet noticed. The pool was the pipeline: analysts became associates became directors, and the firm's understanding was reproduced by promotion. Tokens do not get promoted. Up or out now applies to humans only, and a firm whose understanding lives in its managing directors, with no pool beneath them that is learning to hold it, has a balance sheet with a term.
This is also the answer to what engineering is measured by, now that it is not measured by the mastery of a toolset. A few months ago I needed a frontend engineer who knew the quirks of React or Vue, because I did not know the framework well enough. I no longer hire experts in a toolset; the toolset is in the weights. What is not in the weights is Hayek's knowledge of the particular circumstances of time and place: this business, this client, this invariant, this incident, this reason the abstraction exists. Friedrich Hayek, "The Use of Knowledge in Society" (1945). A résumé that lists frameworks is a list of liabilities already discharged. Engineering is measured by what you can specify, what you can verify, and what you can explain; the middle term is being automated, and the outer two are the job. It follows that we are entering a renaissance of generalists, with one boundary that the enthusiasm usually omits. The specialist was an artifact of the cost of learning a tool, and when the cost went to zero the specialist became a generalist with a favorite; the accidental complexity Brooks separated from the essential is gone, and the essential complexity, the shape of the system and the sentence that describes it, is now the entire job, and it was always the generalist's. Brooks, "No Silver Bullet" (1986). The boundary is Tao's: use the tool only where you could red-team its output yourself. The generalist's territory is the radius of what he can still check; beyond it he is a client, not an engineer. A generalist with agents is a one-person firm, and if each of us has an outsourced engineering team then each of us is an entrepreneur, which explains why the soft skills have become the hard ones. The entrepreneur's four are knowing what to build, getting it accepted, carrying it afterward, and explaining it to someone who will not read the code, and none of them was ever soft; they were merely unmeasured, because the measured thing was the code.
Could we build products with agents? We could, and we have to, and I think the condition on it is now visible. A product is built by a society, and what the agent replaces is not the code but the society. The standups were not status reports; they were the daily occasion on which the theory of the system was renegotiated out loud, in which someone said that cannot be right and someone else explained why it was, and the compromise that came out was the design. Each such occasion had a visible output, a decision or a merge, and an invisible byproduct, the capacity of the people in the room to reach consensus with each other, which was built by the practice of reaching it and depletes without it. We cancelled the standups because nobody needed anyone else to finish, and that was true, and it is also the sentence in which a society dissolves: the pathos of engineering as a shared trade, the pride in the thing we built, is the smaller loss; the larger is that we are losing the ability to build compromises at all, because compromise is a skill exercised only under the necessity of agreement, and the agents have removed the necessity. The agent does not argue back, and a firm whose members no longer have to argue with each other does not become more harmonious. It becomes a crowd of people who have forgotten how. The Thoughtworks report's cohesion floor of about 10 people and its observation that solo shipping with agents "eroded pairing and cohesion" are the only measured versions of this I have found; the Stack Overflow figures on asking and contributing less are the same loss at the scale of the whole trade. Coase's firm, under this reading, is not the region where consensus is cheaper than contracts but the region where consensus is still practiced, and it shrinks as the practice lapses. The lab that builds the agents noticed it in its own building: the engineering lead of Claude Code said in June that working with the agents "could start being a lonely experience," and the company instituted hackathons and pair-programming lunches to compensate, which is a firm putting its society on the calendar because it no longer arises from the work. Fiona Fung on Lenny's Podcast, as reported by Fortune, Jun 23, 2026; the hackathons were "just to make sure we're interacting together as a team." That is the condition. We will build products with agents on the day we have rebuilt, on purpose, the occasions on which people have to agree—the plan reviewed by a room, the talk given to one, the design argued rather than generated, the junior who must be answered—not because the code requires them, since it no longer does, but because the product does. The prototype needs a prompt. The product needs a society, and societies are not generated.
The hardest of the soft skills was never soft at all: declining to merge what you cannot explain. "Senior, whatever that means," turns out to mean something definite. The senior is the one who produces less; whose change enters where there is already space; who can be asked why and will answer without reaching for the machine; and who, asked to approve what he cannot compress, says no and asks for the page. The cook, when he comes to the knot, does not hack through it. He sees the difficulty and grows careful; his eye stops, his hand slows, the knife moves very little, and the thing comes apart like earth falling to the ground. Then he wipes the blade and puts it away. That was the review, when it was easy. The work now is not to review harder. It is to rebuild the conditions under which review can be easy again—the codebook, the plan, the talk given to someone free to refuse it, the pager, the pool that is learning, the table with people still around it—so that the firm goes on producing the one thing it was always for, which was never the code.