The Production Function Changed

The most important thing to understand right now about agentic coding is not “AI writes code.” It’s that the production function of software has changed, and most people are still reasoning with the old one.

A miniature 3D isometric machine continuously printing and stacking sheets of code, styled like a premium Airbnb icon. The device resembles a compact industrial printer with a control screen and conveyor belt, producing neat stacks of blue code tiles. The scene is rendered in soft neutral lighting on a white background, suggesting automated, high-throughput software production.

For decades, software output scaled roughly with human engineering time. The scarce resource has always been human time and attention. More engineers meant more throughput, with coordination costs eating the margins. That mental model is deeply ingrained: planning, staffing, prioritization, and risk management all assume it.

That model is now wrong.

In my day-to-day work, software production is no longer meaningfully constrained by typing, implementation effort, or even iteration speed. Given a clear task and a tight feedback loop, producing patches is effectively unbounded. Systems like Symphony make the shift visible: once the specification is sharp enough, implementation stops being the expensive part. The limiting factor is no longer “can we build this,” but “do we know what we want,” and “will we notice when it’s wrong.”

I haven’t written code by hand in months. My laptop hums with its lid half closed at night, running caffeinate -sdi so a PR or three can get authored, pushed, reviewed and merged while I’m asleep. Maintenance work that used to be deferred indefinitely now runs continuously in the background or gets tasks fired off by replying to a Slack thread with @Codex do it.

My job these days is to teach the machine how to do more and more of the work that I used to do. Guardrails which would have been toilsome to write by hand can be arbitrarily generated as bespoke ESLint rules.

Do not model software as a scarce output. It isn’t anymore. Any time I catch myself thinking “I wish …”, I instead say “@codex please …”. I am more than happy to throw away 80% of these! But those rejections are learnings. The synchronous attention I give to review goes straight back into Codex, so the underlying principles behind a rejected PR get baked into the codebase to guide future agents.

The organizations that struggle over the next few years will not be the ones with “bad AI tooling.” They’ll be the ones still allocating people, time, and attention as if engineering capacity were fixed — long after it stopped being true.