After Authorship

For most of the time software has been a commercial category, the constraint on who could build it was authorship. The person who could not personally render their thinking into code did not ship the company. They could advise. They could fund. They could sit on the board. They could not be the one in the room building. The selection mechanism the industry developed over twenty years was tuned to identify the people who could author the artifact. It learned to read the proxies that correlated with that capacity: institution, age band, prior employer, dense network ties into a small number of cities. The mechanism was not arbitrary. It identified the authors well enough to produce most of the great software companies of the last two decades.

By late 2024, thought could reach software through a different interface. The substrate changed. The mechanism is still running. The constraint it was tuned for is no longer the constraint.

The temptation now is to describe this as the moment when nontechnical founders learned to code. That framing is already becoming consensus, which means it is no longer the interesting observation. The more important one is harder to metabolize. The bottleneck did not disappear. It moved.

For twenty years, the bottleneck was authorship. The hard part was turning thought into shipped artifact through the human hands that could write the code. Models did not eliminate that difficulty. They relocated it. The technology did not make software production easy. It made the easy parts easy and moved the hard parts somewhere else.

You can see the new shape most clearly at the frontier. Boris Cherny, who created Claude Code at Anthropic, described his workflow this month. Sessions running in parallel. Sub-agents working overnight. The engineer checking from a phone. The details matter less than the posture. The work has moved from writing every line to setting the boundary, giving the system a way to verify itself, and deciding what is allowed to compound. The unit of production is no longer the engineer-hour. It is the verified agent loop.

This is the structure the new substrate selects for. Naming what should happen before the work starts. Keeping many agents inside the boundary of what was asked. Telling when the output only looks right. Knowing which decisions will compound and which will not. Preserving the trail after the model, the prompt, and the person who ran them have moved on. Getting the thing into the hands of people who do not care how it was made, only whether it works and whether the trail holds. These capacities compound with use. They are not credentialed. They are practiced. And the proxies the selection mechanism was tuned for, twenty years of institution and pedigree and prior employer, do not predict them.

This is what the older notes on this site have been circling. The new scarce skill is not faster authorship. It is accountable orchestration. The discipline of deciding what should be built. The architecture that carries the weight when implementation comes from agents. The record that lets someone know what shipped, why it shipped, and what was checked before it did. These are the post-authorship capacities. They are the actual entry criteria for building serious infrastructure in this substrate, and they are accessible to anyone willing to cultivate them.

Some of us recognized the new bottleneck quickly because it resembled work we already knew. Operating capital, regulated markets, enterprise consequences. Systems where being approximately right was not good enough. We had spent careers specifying work we did not personally execute, trusting teams without surrendering judgment, and keeping records because memory was not enough. When the medium opened, that discipline carried over. The work translated because the work was recognizable.

There is a particular kind of dislocation in building during the gap. The work is real. The product runs. The customers who feel the integrity problem feel it before the institutions can name it. But the questions arriving from the old function still assume the old bottleneck. Who wrote it. Where did they train. How many engineers. Which network confirmed it. The questions are not malicious. They are late. After a while you stop trying to persuade the function and start building around it.

The selection mechanism updates late. It is doing that again. Much of it still reads authorship proxies because those proxies worked when authorship was the constraint. The cost of the lag is not borne by the mechanism. It is borne by the companies that do not get built, and by the founders read as the wrong shape by a filter optimizing for an era that is ending. Some of those companies will be built anyway, by founders who route around the filter through customer revenue, distribution where agents already live, or capital partners who have already updated their function. Some will not. The investors I have found the conversation easiest with are the ones who have updated. They ask what the founder has built recently, how they specify intent, how they verify what their agents produce, how the integrity of the system compounds with use. They are not yet the majority. They will not stay a minority.

I want to be careful here. This is not an argument that the canonical institutions are now disqualified. Many of the people most clearly naming what changed came from inside them. Cherny himself. Karpathy in his retirement of vibe coding. The engineering leaders running spec-driven workflows at frontier organizations. The point is not that the old founder type is now the wrong type. The point is that the type is no longer the constraint. The constraint is the disciplines. Some people inside the canonical corridors are learning them quickly. Some people outside those corridors arrived with parts of them already formed. The new substrate does not care where the discipline came from. It cares whether the discipline is there.

The harder consequence is what this does to the institutional layer underneath software production. For twenty years, the author was the proxy for accountability. The author was the person you could ask. The author was the trail. Code review, change management, audit, compliance, due diligence, every institution that grounded confidence in software was built around the assumption that there was a human author whose judgment could be inspected if the work failed. When the author is an agent fleet running overnight, that proxy does not hold. The trail has to live somewhere else.

Every serious system eventually learns that trust cannot live inside the thing being trusted. Money needed ledgers. Supply chains needed bills of lading. Public companies needed audits. Software needed logs, reviews, and change histories. Agent work will need its own record, durable enough to survive the conversation, the model version, the deployment, and the memory of the people in the room. Not because the models are bad. Because delegation without a durable trail is not accountability.

What I am willing to be held to is the structural claim. In the authorship era, software production was grounded in the author. After authorship, software production has to be grounded in the receipt. The companies that build that substrate, and the founders the new function will eventually learn to recognize as serious, are the ones who already understand which question they are answering.

It is May 17, a Sunday. Twenty months since the medium opened. The bottleneck has moved. The function will update, eventually. It always does, and always late. The founders building during the gap do not have the luxury of waiting. We build where the weight moved. We leave receipts because memory is no longer enough. That is the work now.