Eighteen months ago, coding with AI felt like pair-programming with a talented but unreliable intern. You'd get bursts of impressive output followed by baffling errors — code that compiled but missed the point, suggestions that solved the wrong problem, refactors that broke things in ways you'd spend an hour debugging. The "junior developer who types fast" analogy was accurate. I used it myself.

It's not accurate any more.

Something crossed the line in late 2025, and the people still citing the limitations of early coding agents are fighting the last war. AI coding isn't an incremental improvement on what came before. It's the most significant shift in how software gets made since the compiler. Since the GUI. And most of the discourse hasn't caught up.

The long ramp that felt like a plateau

I started with GitHub Copilot in mid-2024. It was useful in the way autocomplete is useful — it saved keystrokes, occasionally suggested something clever, and mostly stayed out of the way. Then Claude Code arrived in February 2025, and the dynamic changed. Instead of autocomplete, I had something closer to a collaborator. Still flawed, still requiring constant supervision, but fundamentally different in ambition.

For most of 2025, the improvement curve was real but gradual. Each model update brought fewer hallucinations, better context handling, more reliable multi-file edits. But the core experience stayed the same: you'd prompt, review, correct, re-prompt. The agent was doing work, but you were doing the thinking. And a significant chunk of the time savings got eaten by review and correction cycles.

The sceptics had a point during this phase. METR — the AI safety research organisation — ran a randomised controlled trial with experienced open-source developers and found they actually completed tasks 19% slower with AI tools. The kicker? Those same developers estimated they'd been 20% faster. The perception gap was enormous. And for a while, that finding felt right.

Then November happened

Anthropic released Opus 4.5 on 24 November 2025, and within a week I knew something fundamental had shifted. It wasn't one thing — it was everything at once. Fewer corrections needed. Genuine architectural understanding rather than pattern-matching against training data. The ability to handle real complexity — subtle refactoring, multi-file changes that maintained consistency, debugging that demonstrated actual reasoning about system behaviour.

Opus 4.6 followed on 5 February 2026, and the gap widened further. OpenAI's Codex hit 1.6 million weekly active users. Apple shipped agentic coding in Xcode 26.3, with Claude and Codex running directly in the IDE — creating files, building projects, running tests, checking their own work. When Apple ships something, it's mainstream.

The "junior developer" era didn't fade gradually. It ended. What replaced it feels qualitatively different — not faster assistance but actual creative liberation. I'm building things I wouldn't have attempted two years ago. Not because I couldn't imagine them, but because the gap between imagining and implementing was too wide. That gap has collapsed.

Everyone's a builder now

Here's the part that makes the compiler analogy more than rhetoric.

The Wall Street Journal ran a piece today — 19 March 2026 — about how everyone in San Francisco now calls themselves a "builder". Not developers. Product managers, doctors, construction workers, tweens. A product manager named Madina Gbotoe, who'd never coded before, now runs a freelance web-building business, has an AI agent that books her travel, and built another one to help with her new puppy. A doctor in New Jersey has built ten apps for his medical practice and says he's feeling "the intoxication of what engineers have probably felt for decades". An eleven-year-old learned Claude Code from his dad and built a videogame and an interactive geography website.

These aren't demos. These are people building real things they actually use.

The compiler didn't just make programmers faster. It made programming possible for people who couldn't write machine code. The GUI didn't just improve existing software. It created entirely new categories of user and entirely new categories of product. That's what's happening now. The barrier between "I have an idea" and "I have working software" has dropped to near zero for a class of problems that used to require a development team. As I argued in everyone is a product manager now, the bottleneck has shifted from execution to decision-making — and that changes who matters in the building process.

Andrej Karpathy — who coined "vibe coding" barely a year ago — has already retired the term. His replacement? "Agentic engineering". Because the workflow has matured past vibes. You're not hoping the AI gets it right any more. You're orchestrating agents, setting architectural constraints, reviewing and directing. It's engineering — just a fundamentally different kind.

Why the sceptics are fighting the last war

The counter-arguments are familiar by now. AI-generated code has higher churn rates. GitClear found that code reverted within two weeks has roughly doubled. Academic studies show security weaknesses in a significant proportion of AI-generated code. The METR study showed experienced developers getting slower, not faster.

All of this was true. Some of it is still true for people using yesterday's tools, or using today's tools with yesterday's mental model. But the framing misses the point in the same way that criticising early compilers for generating less efficient machine code missed the point. The question was never "does the compiler write better assembly than a human?" The question was "does the compiler change what's possible?"

Max Woolf — a committed AI sceptic — published a detailed assessment of coding agents in February 2026. He put Claude Code through increasingly ambitious projects, including porting Python's scikit-learn to Rust. His conclusion? He had to update his priors. The tools had genuinely crossed a threshold. Even the sceptics are noticing.

Simon Willison's warning about cognitive debt — the cost of maintaining code you didn't write and don't fully understand — is the most legitimate concern. It's real. But it's also a problem that improves as context windows grow and agents get better at understanding existing codebases. It's a transitional problem, not a permanent limitation.

The real question isn't productivity

The industry is still measuring coding agents on a productivity axis — do they make developers 20% faster? 40%? The METR study says maybe slower. The marketing says 10x. The reality is probably somewhere between 30% and 50% on well-scoped tasks, and that number keeps climbing with each model generation.

But productivity is the wrong frame. It's like asking whether the printing press made scribes faster. Technically, yes. But that's not why it mattered.

AI coding matters because it changes who can build and what gets built. A doctor in New Jersey is building healthcare apps. A product manager is running a web agency. A kid is making educational games. These things weren't going to happen through "productivity gains for existing developers". They're happening because the barrier to creation fell below a new threshold — and a wave of people who think in problems rather than syntax are now building solutions.

Karpathy is right that this needs a new name. "Vibe coding" was the early phase — messy, exciting, unreliable. What we have now is more structured, more powerful, and more consequential. The gap between skilled and unskilled use is still enormous, and learning to work with these tools well is a genuine skill. But the ceiling has risen dramatically.

Act accordingly

If you're a developer, the old advice about treating coding agents as junior developers isn't wrong — it's just eighteen months out of date. Treat them as capable colleagues who need architectural direction but can handle serious implementation work. Build the habits of agentic engineering: clear specifications, architectural guardrails, systematic review. The developers who thrive won't be the ones who type fastest. They'll be the ones who think most clearly about what to build and how to direct the agents building it.

If you're not a developer, the barrier to entry just vanished. The WSJ piece is full of people who discovered this in the past few months. The tools are Claude Code, Replit, Cursor, Codex. The skill is learning to describe what you want clearly and iterating on the result. It's not trivial — but it's not a computer science degree either.

The compiler didn't just make programming faster. It made modern software possible. The GUI didn't just improve existing applications. It created the personal computer revolution. AI coding agents are in the same category — not because they're perfect, but because they've crossed the line where something fundamentally new becomes possible.

The sceptics will catch up. The data will follow. But the people building things right now aren't waiting for permission.