The best engineers are starting to worry they can't tell the difference between code that works and code that just looks like it works.
The Summary
- Simon Willison warns that "vibe coding" — accepting AI-generated code based on vibes rather than understanding — is converging with agentic engineering, where AI agents write and deploy code autonomously
- The debate drew 340 comments on Hacker News, with engineers split between those who see agents as inevitable and those who see them as technical debt factories
- Critics argue agentic coding creates a trap: you ship faster today but inherit unmaintainable systems tomorrow when the agent can't fix what it built
- The core tension: AI coding tools are getting good enough to ship, but not good enough to maintain
The Signal
Willison's concern cuts deeper than the usual "AI will replace programmers" discourse. He's pointing at something more insidious. Vibe coding is when you ask Claude or GPT to write a function, scan it quickly, think "yeah that looks right," and merge it. You're not reading every line. You're not tracing the logic. You're pattern-matching against code you've seen before and trusting the vibe. Most engineers do this now, at least sometimes. The code usually works.
Agentic engineering takes this further. The agent doesn't just write code. It runs tests, reads error messages, fixes bugs, deploys to production. You're not even looking at the code anymore. You're looking at the output. The API returns the right JSON. The page loads. Ship it. This is where the trap closes.
"You ship faster today but inherit unmaintainable systems tomorrow when the agent can't fix what it built."
The problem isn't that the code is bad. It's that nobody understands it well enough to fix it when requirements change or edge cases emerge. The agent that wrote it might be three versions old, trained on different data, using deprecated libraries. You're left holding a codebase that "works" but that no human can confidently modify. Technical debt used to mean shortcuts you took knowingly. Now it means entire systems you never understood in the first place.
The Hacker News thread split predictably. Half the comments are from engineers who've already crossed this line and don't see a way back. They're shipping features 5x faster. Their users are happy. Code review is a bottleneck they've automated away. The other half are the ones who've been called in to debug agent-generated systems at 2am. They've seen what happens when the vibes were wrong.
Key fault lines in the debate:
- Speed vs. understanding: Ship 5x faster now, or maintain 5x easier later?
- Testing as substitute for comprehension: If the tests pass, does it matter if you understand the code?
- Individual productivity vs. team maintainability: One engineer moves fast, the whole team slows down
What makes this harder is that vibe coding and agentic engineering aren't binary. You're not either reading every line or trusting the agent completely. Most teams are somewhere in the middle, using AI to draft boilerplate and scaffold APIs while still writing core logic by hand. But that middle ground is shifting. As agents get better at the hard parts, the temptation to let them handle more grows. The line between "AI-assisted" and "AI-authored" blurs.
The Implication
If you're building with AI coding tools, you need a new kind of code review. Not line-by-line syntax checks, but architectural review. Can a human who didn't write this code understand the system well enough to extend it six months from now? If the answer is no, you're taking on technical debt even if the code is pristine.
For engineering leaders, the question is simpler: are you optimizing for shipping features or for maintaining systems? Because agentic coding optimizes hard for the first at the expense of the second. That tradeoff might be worth it for MVPs, prototypes, or code you plan to rewrite. But for core infrastructure, betting on agent-generated code you don't deeply understand is betting you'll never need to change it.
Watch what happens when the first major platform built primarily by agentic engineering hits a crisis that requires deep architectural changes. That's when we'll know if this is a paradigm shift or just a very expensive form of technical debt.