AI Coding Slower, Better: Why the '10x Productivity' Hype Is Being Challenged
The Dark Side of AI "10x Developers"
"Vibe coding" — writing code with AI, barely reading it, merging PRs rapidly — is the hottest trend among developers in 2026. The "10x productivity" slogan appears everywhere, from GitHub Copilot marketing to YouTube videos praising AI coding agents.
But an essay just hit 1,219 points on Hacker News that made developers stop and think. Nolan Lawson, a veteran developer, flips the question: what if AI isn't for writing code faster, but for writing better code?
Not a "Slop Cannon," But a Quality Engine
The term "slop cannon" is gaining traction in the community to describe how many developers use AI: throw in a prompt, receive a multi-hundred-line PR, merge without review. The result is a codebase full of bugs, loose logic, and mounting technical debt.
Lawson argues that LLMs are highly flexible. They can be used to review for bugs instead of creating new ones.
In his experience, the latest models from Anthropic and OpenAI are so good at finding bugs that the problem is no longer finding them — it's prioritizing and validating them. An unscrutinized codebase typically has so many bugs surfaced that you'll get bored before you fix them all.
The Method: Multiple Models, Multiple Angles
Lawson built a workflow based on a core insight: the more diverse models that review the same PR, the fewer hallucinations slip through.
His concrete pipeline:
- Send the PR to multiple agents simultaneously: Claude sub-agent, Codex, and Cursor Bugbot
- Each agent ranks bugs by level: critical / high / medium / low
- Personally review all findings, ruling out false positives
- Only fix critical + high, iterate until no critical/high remain
The result, according to Lawson: the false positive rate is near zero.
The interesting part: this workflow also uncovers pre-existing bugs — flaws that were in the codebase before the PR was created. Lawson frequently ends up on "side-quests" writing unit tests and fixing old issues.
"Slow" Doesn't Mean Inefficient
There's an interesting paradox here. "10x productivity" in lines of code doesn't equal 10x value. A 500-line PR merged in 30 minutes that creates 3 production bugs can cost far more than the time "saved."
Conversely, a 100-line PR that takes 3 hours to review thoroughly with AI can:
- Have zero critical bugs
- Discover and fix 2 pre-existing codebase bugs
- Include comprehensive unit tests
- Leave behind Markdown docs + Mermaid diagrams for teammates
This development flow is slower but accumulates quality. Each PR doesn't just add a feature — it improves the overall health of the codebase.
When to Use "Slow" AI Coding
This flow works best for:
- Production projects where bug leakage carries high risk
- Complex codebases the developer doesn't fully know yet
- Large pull requests that need review but the team is understaffed
- Major refactors — AI finds where assumptions break down
Prototypes or personal projects don't need this level of scrutiny.
Specific Techniques
Beyond the multi-model review pipeline, Lawson suggests several complementary techniques:
Ask AI to explain its own PR. Before merging, ask the agent: "Explain how this PR works and where it might fail." If the AI can't explain it clearly — that's a red flag.
Use Mermaid diagrams. Ask AI to draw sequence diagrams or flow charts for complex logic. A picture is worth a thousand lines of code — and helps future reviewers understand faster.
The "grill-me" skill. Matt Pocock created a skill where AI interrogates its own code like a tough reviewer. This technique catches faulty assumptions before they hit production.
Define "bug" clearly. Lawson's prompt also includes criteria for KISS (Keep It Simple, Stupid), DRY (Don't Repeat Yourself), accessibility-compliant HTML/JSX, and SQL queries needing proper indexes.
Go: The Language AI "Loves" Most?
Another interesting community insight: Go is emerging as the ideal language for working with AI. Not because Go is "best," but because:
- Consistent training corpus: Only one way to write Go (gofmt, go vet, golangci-lint)
- Simple concurrency model: Goroutines — no worrying about "function coloring" like async/await
- Powerful standard library:
net/httpruns a significant portion of the internet's microservices - Low fragmentation: Unlike JavaScript with dozens of overlapping frameworks
Coding agents produce far more consistent output with Go than with JavaScript or Python — two heavily fragmented ecosystems.
Conclusion
There's no single way to use AI for coding. "Vibe coding" — fast, minimal review — suits prototypes. But for production, Nolan Lawson's approach offers a different vision: AI as reviewer, not code monkey.
Use AI to find bugs, analyze code, and ensure quality. Slower — but better code. Your teammates will thank you.
Are you using AI to write code faster, or to write better code?
References: