The Coder Without Code

Andrej Karpathy named this "vibe coding" in February 2025 and the industry immediately split into two camps: the evangelists who saw democratization, and the practitioners who saw a generation of software about to inherit production servers it couldn't explain. Both camps are partly right, which makes the argument more annoying, not less.

The core insight — that LLMs can generate functional code that non-programmers can deploy — is accurate. The conclusion drawn from that insight — that coding is therefore over, or that programming skill is now optional — is where the narrative went sideways. What actually happened is more interesting and more depressing than either camp wants to admit.

i · the vibes don't know about your database schema

Simon Willison spent most of 2025 trying to draw a line that kept getting erased. His March post on the subject made it precise: vibe coding is specifically what happens when you "forget that the code even exists" — when you accept an LLM's output without reviewing it, without understanding it, without being able to explain it to someone else. By that definition, it's not really a programming technique at all. It's a deployment strategy with plausible deniability.

The distinction matters because software has stakeholders. That weekend app for generating party playlists can be vibe-coded into existence, break in three different ways, and nobody dies. The employee database at a 500-person company is different. The checkout flow is different. Anything involving secrets, credentials, other people's data, financial transactions — these systems exist in a world where "it appears to work" is not a success criterion.

Willison was explicit about this: "If your code involves secrets you need to take care not to accidentally expose them, which means you need to understand how the code works!" This is the part of the democratization narrative that gets quietly omitted. The barriers to creating software have genuinely dropped. The consequences of bad software have not. If anything, they've scaled.

What the vibe coding discourse sold as a revolution in access was partly true — a new class of amateur builders can now produce functional tools. But "functional" is doing a lot of work in that sentence. Functional in the demo. Functional when the right user does the expected thing. Functional until someone unusual appears, or a dependency updates, or the prompt that generated the authentication logic had a subtle misunderstanding of your session model.

The gap between "the app runs" and "the app is safe, maintainable, and correct" did not narrow. It just became invisible to the person shipping the app.

ii · the senior developer's escape hatch

While the debate about vibe coding was still trending, something different was quietly happening among experienced engineers. By October 2025, Willison had a new frame for it: "vibe engineering."

The terminology is deliberately provocative — taking the casualness of "vibe" and attaching it to "engineering," which has always implied rigor. The point is that the fast, agent-assisted workflow that looks like vibe coding from the outside is something categorically different when a senior developer is at the controls.

The difference is accountability. A vibe coder accepts what the LLM produces. A vibe engineer "stays proudly and confidently accountable for the software they produce." Parallel agents, multiple workflows, rapid generation — but with code review, automated tests, and the ability to maintain what gets shipped. Same tools, completely different relationship to the output.

What emerged from Willison's exploration of parallel coding agents was a shift in bottlenecks. The constraint for an experienced engineer using agents isn't writing speed anymore — it's review capacity. "I can only focus on reviewing and landing one significant change at a time," he noted, "but I'm finding an increasing number of tasks that can still be fired off in parallel." The programmer becomes an orchestrator. The queue of agents replaces the blank cursor.

This is where the vibe coding conversation started missing its own point. The question isn't whether LLMs can generate code — they can, obviously, they have been, this is settled. The question is: who's qualified to decide whether the generated code is any good? The answer, uncomfortably, is still someone who could have written it themselves.

Willison's framing: "AI tools amplify existing expertise." The amplification metaphor is important. An amplifier doesn't add signal — it makes the existing signal louder. Point it at a senior developer's judgment and you get faster, broader output. Point it at an absence of judgment and you get the same thing, amplified.

iii · what the skills shortage actually looks like

The optimistic version of the AI coding story goes: junior developers become senior overnight, the bottleneck of expertise disappears, everyone builds. The pessimistic version is nihilistic in the opposite direction: all developers are replaced, nobody codes, the profession dissolves.

What's actually happening is neither. It's more like a compression of skill requirements toward the top, combined with a genuine expansion of access at the bottom, with a dangerous gap in between.

At the top: experienced developers are genuinely more productive. The tasks that used to consume junior hours — boilerplate, documentation, test generation, dependency archaeology — get delegated to agents. Estimation paradoxically gets harder, because agents speed execution while obscuring complexity. Architecture still requires someone who understands what architecture is for. Willison's list of what agentic development actually requires — automated testing, planning and documentation, code review culture, manual QA and research skills — looks suspiciously like the list of things senior developers were doing before LLMs existed.

At the bottom: a genuine expansion. Non-programmers building personal tools, one-person operations shipping things that would have needed a contractor six years ago, researchers automating their own workflows. This is real and mostly good. The vibe-coded birthday reminder app that breaks on leap years is a rounding error compared to the value created by lowering that barrier.

In the gap: the danger zone. Software that looks production-ready because it runs, built without the understanding to maintain it, deployed into contexts where the failures aren't amusing. Researchers studying AI-assisted development have started calling this "cognitive debt": developers who build fast without comprehension lose ownership of their own systems. The code works until it doesn't, and then nobody knows why.

The industry hasn't figured out how to price this risk yet. The vibe-coded startup looks the same as the carefully engineered one until the breach, the crash, the corrupted data, the lawsuit. By then the person who generated the code with a prompt has moved on to the next project.

iv · what survived

This is where the debate usually resolves into something obvious in hindsight: the floor has risen but the ceiling hasn't moved.

What actually got deprecated: the mechanical parts of programming. Typing syntax. Looking up API signatures. Writing boilerplate that you've written seventeen times in three languages. The cognitive load of holding the shape of a well-understood problem in your head long enough to transcribe it into code.

What didn't get deprecated: the judgment about what to build, how to structure it, which trade-offs to accept, and how to know when the generated solution is solving the right problem. The ability to read code and know what's wrong with it. The experience to recognize that "appears to work" is not the same as "is correct."

The coder without code isn't some new kind of professional. They're a familiar type: someone who's made the easy part look like the whole job. Software's history is full of tools that automated away the hard work of thinking — visual IDE builders, low-code platforms, earlier generations of AI code completion. Each time, the experienced practitioners adapted and the inexperienced ones discovered that the tool had automated the transcription, not the understanding.

Willison, writing in October 2025, was still reviewing code. Running agents, yes. Shipping faster than before. But accountable for what shipped. That accountability is the job. It was always the job.

The vibes were never the point.

v · sources

• Not all AI-assisted programming is vibe coding — Simon Willison, 2025-03-19
• Vibe engineering — Simon Willison, 2025-10-07
• Embracing the parallel coding agent lifestyle — Simon Willison, 2025-10-05