Willison argues that agentic engineering was supposed to be the disciplined counterpart to vibe coding, with human checkpoints and test harnesses. But in practice, agents are taking on increasingly large scopes of work while humans rubber-stamp the output, making the two approaches converge. He frames this as an uncomfortable truth the industry hasn't wanted to name.
The editorial argues that the vibe-coding vs. agentic-engineering distinction isn't just semantic — it's the framework that lets engineering leadership approve AI tools. When a VP of Engineering signs off on an AI coding agent, they're buying the promise of guardrails and structured review, not unreviewed generation. If Willison is right that the gap is closing, the political and organizational justification for these tools becomes precarious.
By surfacing and promoting Willison's piece, e12e signals alignment with the framing that the community needs to grapple with where on the spectrum of AI-assisted coding actual practice falls. The implicit position is that the binary framing of 'vibe coding bad, agentic engineering good' was always too simplistic, and practitioners need a more honest reckoning with how much review is actually happening.
Simon Willison — Django co-creator, prolific open-source contributor, and one of the most consistently rigorous voices on AI-assisted development — published a piece on May 6, 2026 arguing that the boundary between "vibe coding" and "agentic engineering" is eroding faster than the industry wants to admit. The post landed on Hacker News with a score of 102, triggering the kind of debate that only surfaces when someone names a thing people have been feeling but haven't articulated.
The distinction Willison is interrogating traces back to early 2025, when Andrej Karpathy coined "vibe coding" to describe a workflow where you let an LLM generate code and accept it without deep review — coding by vibes, not comprehension. The term was initially lighthearted, almost celebratory. But it quickly became a fault line in the developer community: on one side, people building weekend projects and prototypes at unprecedented speed; on the other, engineers warning that shipping unreviewed AI-generated code to production was a slow-motion disaster.
"Agentic engineering" emerged as the serious counterpart — structured workflows where AI agents operate within defined constraints, with human checkpoints, test harnesses, and review loops. Tools like Claude Code, Cursor, Devin, and a growing ecosystem of coding agents promised to deliver the speed of AI assistance with the rigor of engineering discipline. Willison's provocation is that this distinction is increasingly theatrical: the agents are doing more, the humans are reviewing less, and the gap between the two approaches is narrowing to a difference in marketing rather than methodology.
This matters because agentic engineering has become the load-bearing justification for AI adoption in serious engineering organizations. When a VP of Engineering approves an AI coding tool, they're not approving vibe coding — they're approving a disciplined workflow with guardrails. Willison is pulling at the thread that asks: are those guardrails real, or are they the engineering equivalent of security theater?
The fundamental tension is architectural: as agents become more capable, the optimal workflow involves giving them longer chains of autonomous action. An agent that can read a codebase, write a feature, generate tests, and open a PR is more useful than one that stops after each line for approval. But every step you add to the autonomous chain is a step removed from human comprehension. At some point, you're reviewing a diff that's the output of 200 intermediate decisions you didn't witness, and your "review" is pattern-matching on the final output — which is exactly what vibe coding is.
Willison has been building in public with these tools for over a year, documenting his workflows with unusual transparency. He's not an AI skeptic or a Luddite — he uses Claude Code extensively and has been one of its most effective advocates. That's what gives this piece weight. When someone who ships production code with AI tools daily says the guardrails are thinner than advertised, it carries a different valence than the same argument from someone who's never touched the tooling.
The counterargument, well-represented in the HN discussion, is that this is a tooling problem, not a fundamental one. Better diff viewers, smarter test generation, formal verification layers, and agent-generated explanations of their reasoning could restore meaningful human oversight without sacrificing autonomous capability. But Willison's implicit point is that the economic incentives all push toward less review, not more. Developers are measured on output. AI tools are marketed on speed. The path of least resistance is always to trust the agent and ship.
There's a second, subtler dimension here. Vibe coding at least has the virtue of honesty — the practitioner knows they're not reviewing the code deeply. Agentic engineering can create a false sense of rigor. You ran the agent in a "structured workflow" with "guardrails," so surely the output is trustworthy. This is the same cognitive trap that makes automated testing dangerous when teams treat green CI as proof of correctness rather than absence of detected failure.
If you're using agentic coding tools in production workflows — and in 2026, most teams are — Willison's argument demands a concrete audit. Ask yourself: for the last 10 AI-generated PRs your team merged, could any reviewer articulate the key architectural decisions the agent made, or were they pattern-matching on the final diff? If it's the latter, you're vibe coding with a governance wrapper.
Practical steps worth considering:
Shrink the autonomous chain deliberately. Instead of letting an agent go from ticket to PR, break the workflow into segments where a human makes an actual decision — not rubber-stamps a diff, but chooses between agent-proposed approaches. This is slower. It's also the difference between understanding your codebase and renting comprehension from an API.
Invest in agent observability, not just output review. The most valuable agentic workflows in 2026 are ones that expose their reasoning chain, not just their final output. If your agent doesn't explain why it chose approach A over approach B, you're reviewing a black box. Tools that surface decision points — where the agent considered alternatives and chose — give reviewers something meaningful to evaluate.
Set explicit vibe-coding boundaries. Not all code needs the same rigor. Prototype code, internal tools, and throwaway scripts are legitimate vibe-coding territory. The danger isn't vibe coding itself — it's vibe coding that thinks it's engineering. Make the boundary explicit on your team: this repo is vibe-coded, this one requires human-comprehended reviews, and here's how we enforce the difference.
Willison is naming a problem that will define the next phase of AI-assisted development: not whether AI can write code (it can), but whether the workflows we've built around it actually deliver the oversight they promise. The industry's answer so far has been to add more tooling — better agents, smarter reviews, automated guardrails. Willison's quieter suggestion is that the answer might require less automation at critical junctures, not more. As agents grow more capable through 2026 and beyond, the teams that thrive will be the ones who can honestly answer the question: do we understand what we're shipping, or have we just gotten comfortable not asking?
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.