When the Code Writes Itself: Two Shifts Rewriting Software and the Future of Work
Two constraints shaped every tool on your desk — who could build software, and who had to drive it. Both are dissolving at once, and the question of where humans add value is becoming impossible to answer with confidence.
Every tool on your desk was designed under two assumptions so basic that nobody thought to write them down.
The first: that building software requires professional software engineers. The second: that operating software requires a human looking at a screen.
Neither is a law of nature. Both are constraints — accidents of what was possible when these systems were designed. And both are dissolving at the same time, which is why this moment feels less like an upgrade and more like a change of category.
Both shifts, one frame. Building software and driving software were separate problems with the same shape — a chain of human handoffs in the middle. In both, that middle collapses to a single step.
The person who understands the problem can now build the solution
Think about what it used to take to get a piece of internal software built.
You start with someone who actually understands the problem — a planner, an underwriter, a site manager, a clinician. They know precisely what the tool should do, because they've felt the absence of it every day for years. But they can't build it. So they describe it.
That description becomes a specification. The specification goes to an engineering team, which has its own backlog and its own reading of the words. It needs budget. It needs hosting, security review, a maintenance owner. It needs a place in a roadmap. Somewhere between six months and two years later something ships — and it's usually a slightly blurred photocopy of what the expert originally had in their head.
The obvious cost of that pipeline was money and time. The less obvious cost — the expensive one — was translation. Every handoff is a lossy compression of domain knowledge, and the nuance that gets dropped is often the whole point of the tool.
The worse consequence was everything that never got built at all. An enormous long tail of useful, specific, small-audience tools were simply never worth the overhead. They stayed as spreadsheets, manual processes, and things people just put up with.
That economics has broken. Domain experts can now produce working, genuinely capable software by describing what they want. Andrej Karpathy — who coined the term "vibe coding" in February 2025 — frames this as a third era of software, in which natural-language prompts do the programming at runtime. His summary of it is hard to improve on:
The hottest new programming language is English.
— Andrej Karpathy, Software Is Changing (Again), 2025
What that unlocks is not primarily speed. It's that the translation layer disappears. The person holding the domain knowledge and the person building the tool are now the same person, so nothing is lost in between.
Shift one. The middle of the chain disappears — and with it, everything that used to get lost in translation.
There's a real catch, and it's worth being honest about it. The bar moves from "can we build this?" to "should we, is it safe, and who owns it in eighteen months?" Generated code still needs review, security posture, data handling and a maintenance story. Karpathy himself has moved past the looser end of vibe coding, arguing that the serious version looks more like directing AI systems with engineering discipline than abandoning judgement. Removing the engineering bottleneck doesn't remove the engineering questions. It relocates them.
The app stops being a place you go
The second shift is slower-moving and, I think, bigger.
Almost every system in a modern organisation was designed on the premise that a human drives it visually. That premise produced screens, menus, forms, dashboards, tabs. It's so pervasive that we mistake it for what software is.
The hidden consequence is that humans became the integration layer. In most real workflows, the person is the connective tissue: reading a value out of one system and typing it into another, chasing a status, reconciling two views of the same customer, assembling a report from four sources. Not because that work is valuable, but because the systems were never built to talk to each other. They were built to be looked at.
Shift two. The human moves out of the middle. The app stops being somewhere you go and becomes a capability something else calls.
What changes this isn't chat interfaces as such. It's models becoming reliable at long-horizon, abstract, multi-step tasks. Once that holds, the natural interface is a statement of outcome rather than a sequence of clicks, and the AI handles the routing: understanding the request, deciding which systems are involved, calling them directly, carrying context between them.
The app doesn't disappear. It recedes — reached by API rather than by a person navigating to it.
Two data points suggest this is further along than it feels. MCP was broadly adopted through 2025 as a standard for connecting AI systems to external tools, databases and APIs, turning bespoke integration work into something closer to plug-and-play. And Gartner projects that 40% of enterprise applications will embed task-specific agents by the end of 2026, up from under 5% a year earlier.
The honest counterweight: most organisations aren't ready, and the constraint isn't the AI. IBM's read on 2025 landed on exactly this — the interesting problem is whether the APIs already sitting inside enterprises are actually exposed and usable. An agent can only reach what has been made reachable.
For fifty years the shape of software was set by two human limits: who could build it, and who was available to drive it.
It's tempting to treat these as separate trends. They're the same trend seen from two ends. Every convention we have — the GUI, the app, the roadmap, the ticket queue — is downstream of those two limits. Remove the first and the set of software worth building expands enormously. Remove the second and the structure of software changes, because it no longer has to present itself to a pair of eyes.
Where the value goes
If both constraints are going, the obvious question is what becomes scarce instead. Value always pools around whatever is still hard.
For decades the hard, expensive thing was implementation. Turning an idea into working software took specialised people, real money and real time — so that's where organisations concentrated their attention, their hiring and their status. The idea was assumed to be the easy part.
The scarce thing keeps moving. Each time we automate what was hard, value relocates to whatever is still hard — and there's no guarantee the column on the right stays ours.
That inverts. When implementation collapses in cost, the bottleneck moves to what AI doesn't hand you for free: idea (noticing the problem worth solving), vision (knowing what good looks like, and what to say no to), and execution (shipping, sequencing, owning the outcome).
The line I'd put on it: the code was never the value. The code was the tax you paid to get the value. When the tax drops close to zero, what's left is the part that was always genuinely hard.
Why this feels urgent now
A fair objection is that people have predicted this for years. What makes now different?
The models have become capable at exactly the thing that was missing: long, abstract, multi-step work that holds together over time. The clearest recent marker is OpenAI's GPT-6, codenamed Astra, released on 3 September 2026 and positioned specifically as a reasoning model for long, complex, multi-step work across coding, computer and browser use, science and professional analysis. Before release, an internal version was reported to have produced ten new results in mathematics and theoretical computer science — generating new work, not summarising existing work.
Five days later came the sharper demonstration. On 8 September 2026, mathematicians at OpenAI announced that roughly 10,000 autonomous agents under their direction, running on an internal model more capable than Astra, had found a singularity in the three-dimensional Navier–Stokes equations — resolving one of the Clay Institute's Millennium Prize Problems, open for some ninety years. The work took about 88 hours and was formally verified in Lean. Two caveats matter: OpenAI says it doesn't intend to claim the prize, and the Clay Institute still lists the problem as active pending verification.
Two things make this relevant here rather than merely remarkable. First, the method. This wasn't one model answering a question; it was ten thousand agents orchestrated toward a single long-horizon goal — the same architecture described above, pointed at mathematics instead of a business function. Second, the controversy that followed. OpenAI began the effort on 1 September after hearing rumours that two mathematicians working with Anthropic models had resolved a related problem, which raised an uncomfortable question about whether researchers can safely use frontier tools on unpublished work.
That capability is what turns both shifts from plausible to imminent. And it points at something more unsettling: recursive self-improvement, where AI systems increasingly help build the next generation of AI. Once a model is good at long, hard, abstract problems, "improve the next model" is itself a long, hard, abstract problem it can contribute to.
Which is why the most telling signal isn't a benchmark. It's who is now asking for the brakes. On 12 September 2026, Anthropic CEO Dario Amodei published an essay calling for a deliberate slowdown of frontier development, warning that capabilities are advancing faster than researchers can understand or control, and pointing specifically at recursive self-improvement. In a genuinely rare display of unity, both Sam Altman and Elon Musk backed it.
Stated precisely, so it doesn't sound alarmist: Amodei frames this as pacing the frontier, not halting it — giving independent evaluators time to test increasingly powerful systems. But the underlying message is the part that matters. The people with the most to gain from racing ahead are the ones saying the curve is steep enough to be worth slowing down.
The harder question: where do humans keep adding value?
There's an uncomfortable recursion in everything above, and I'd rather name it than leave it sitting underneath.
I said value moves from implementation to idea, vision and execution. That's true of this moment. But it assumes those things stay uniquely human, and I'm not confident they do. The curve that erodes the value of writing code doesn't politely stop at the edge of domain expertise. Expertise is pattern recognition built from exposure, and that is precisely what these systems are good at acquiring. Idea generation and business execution look like the next things in line, not permanent human territory.
The architecture already looks like a company
This isn't a distant extrapolation. The dominant design pattern for agentic systems is an orchestrator agent coordinating a swarm of specialists — one for finance, one for marketing, one for IT — which is to say, an org chart. More advanced framings describe a level at which people manage interconnected fleets of agents running entire business functions. There's even a credible prediction that this year will produce the first small business revealed to have been run end-to-end by AI, from director through marketing and accounting, raising unresolved questions about who is liable when software makes every operational decision.
The honest qualifier matters. Fully autonomous general-purpose agents remain more theory than practice; most work well in narrow domains under human oversight, and the expert consensus sits firmly on supervised rather than unsupervised autonomy — not because models can't act, but because governance, permissions and auditability aren't solved. Gartner expects a large share of agentic projects to be cancelled before the end of 2027 for exactly those reasons.
But "supervised, in narrow domains, for now" describes the current rung of a ladder, not the ladder. Strategy, campaign design, financial administration, responding to external events — these are already being orchestrated in pieces. The question isn't whether the pieces join up. It's what's left for us when they do.
The part I can't answer
I have two small children, aged four and two. And I find I genuinely cannot picture what work looks like for their generation. Not in the way every parent half-jokes about not understanding the future — I mean I can't construct a plausible description of what they'll be paid to do.
Every previous wave of automation displaced a category of labour and created another, and the reassuring version of this story says it will happen again. What's different is that the thing being automated is the general capacity to figure things out. When machines took the physical work, we moved to cognitive work. It isn't obvious where we move when the cognitive work goes too. That's not a doom-laden claim — just an admission that the usual reassurance rests on a pattern that may not hold.
The optimistic reading
My hopeful version: value migrates to what's irreducibly human. Empathy. Presence. Trust. Care. The judgement that comes from having lived something rather than read everything written about it. Relationships, persuasion, the ability to sit with someone in a hard moment, the accountability of a person who can be held responsible.
There's something appealing about that as an endpoint — a highly technological society that ends up rewarding the oldest human qualities we have. For two centuries we've optimised people to be reliable components in industrial and then informational systems, rewarding them for behaving somewhat like machines: consistency, throughput, process compliance. If machines do that better, the differentiated human contribution becomes the part we had to suppress in order to be good employees. A reversion to traditional human values, arrived at through the most advanced technology we've ever built. I'd take that.
Why I'm not naive about it
I don't think it's that tidy, for two reasons.
The first is distributional. "Value shifts to empathy and connection" says nothing about whether that value is paid, or to whom. Care work is the clearest example we have of genuinely irreplaceable human labour, and we already systematically underpay it. A transition that moves value toward human qualities but not toward human incomes isn't the good outcome — it's the same outcome with better branding. Who captures the surplus is a policy question, and it won't answer itself.
The second is that the people building these systems are ringing the bell themselves. When Amodei calls for pacing the frontier and Altman and Musk — who have every commercial reason to disagree — publicly back him, that isn't ordinary risk-management language. You don't get to hold the optimistic view about where human value lands while ignoring the people closest to the technology saying the speed itself is the hazard.
So I hold both. The optimistic case is real and worth working toward deliberately, because these outcomes are made rather than received. And the warnings are real too, and come from the least likely sources, which is exactly what makes them worth listening to.
If there's a conclusion, it's that "where do humans add value?" has stopped being a rhetorical question with a comfortable answer. It's an open one. And the fact that I can't answer it for a four-year-old and a two-year-old is the most honest thing I can say about where this is heading.
References and further reading
Roughly ordered by how much weight they carry in the argument above.
- Andrej Karpathy — Software Is Changing (Again) / Software 3.0 — The core reference for the first shift. Slides and full transcript, including the "English as a programming language" framing.
- Notes on Karpathy's Software Is Changing (Again) — A shorter, timestamped write-up of the same talk.
- Seven agentic AI trends to watch in 2026 — Source for the MCP standardisation point and the Gartner projection on embedded agents.
- OpenAI — GPT-6 Astra — Primary source for the "why now" section: a model built for long, complex, multi-step work, released 3 September 2026.
- Quanta — AI has solved one of maths' Millennium Prize Problems — The clearest account of the Navier–Stokes result: 10,000 agents, the Lean verification, and why mathematicians are divided.
- OpenAI — On the Navier–Stokes Millennium Prize Problem — The primary statement, including the timeline and the decision not to claim the prize.
- Nature — OpenAI claims huge maths breakthrough — The scientific-press read, with the Clay Institute's response.
- Amodei calls for an AI slowdown; Altman and Musk agree — The slowdown story, dated 12 September 2026, and the recursive self-improvement concern behind it.
- What "pacing the frontier" actually means — The nuance that this is a proposal to pace rather than halt.
- IBM — AI agents: expectations vs. reality — The counterweight on readiness. Locates the problem in exposed APIs rather than model capability.
- AI agents in 2026: how businesses will use them differently — The orchestrator-plus-specialists pattern that mirrors an org chart, plus the caveat on general autonomous agents.
- What "autonomous finance" actually means in 2026 — The best corrective to overclaiming: autonomy as a spectrum, governance as the binding constraint.
- The 2026 AI agent transition — Where the levels-of-autonomy framing comes from.
- Agentic AI takes the wheel: a deep dive into 2026 — Origin of the prediction about an entirely AI-run small business.
- Vibe coding — Origin and dating of the term, plus the critiques of it.
- Karpathy's newer framing, beyond vibe coding — Where his thinking went next.
- Berkeley CMR — The non-human enterprise — The academic entry, on organisational-structure implications.
Discuss this research
Want to explore how these findings apply to your portfolio or organisation?
Get in touch