Quality Over Velocity: The Case for Slow AI Coding

Nolan Lawson suggests that instead of using AI to rapidly generate low-quality code, developers should use it as a rigorous multi-agent review tool to find deep-seated bugs. This approach involves using different LLMs to critique PRs, which often uncovers pre-existing issues and forces a more thorough understanding of the codebase. Although this method may reduce development speed, it results in significantly higher code quality and a more disciplined engineering practice.

Key Points

• AI is highly effective at finding bugs and vulnerabilities when used as a multi-agent review system rather than just a code generator.
• Using multiple different LLMs to review the same PR reduces hallucinations and false positives through a consensus or debate mechanism.
• This 'slow' approach to AI coding prioritizes code quality and long-term maintainability over raw output speed.
• Engaging with AI tools to explain code or 'grill' the developer ensures the human author fully understands every change being made.
• The process often leads to fixing legacy issues, which improves the overall health of the codebase even if it slows down the current PR.

Sentiment

The overall sentiment is cautiously positive and broadly aligned with the article. Hacker News largely accepts the argument that AI coding should be slower, more deliberate, and more review-driven, especially when the human remains accountable for design and verification. The strongest disagreements are not against using AI at all, but against over-delegating authorship, trusting generated code without deep understanding, or mistaking short-term output for lasting quality.

In Agreement

• Using AI as an adversarial reviewer, planning partner, test writer, and architecture critic can produce more robust code than treating it as a fast code generator.
• Multi-model workflows are valuable because different models bring different strengths, and independent review helps catch corner cases, design risks, and missing tests.
• Slow, spec-first AI workflows keep the developer in control while still saving effort on research, repetitive implementation, documentation, and exhaustive review passes.
• The bottleneck has shifted toward judgment, taste, validation, and knowing what to ask for; those skills become more important as code generation gets easier.
• AI can be a strong tutor or rubber duck because it forces developers to articulate requirements, compare tradeoffs, and reason through their own designs.

Opposed

• Agentic coding can remove the micro-architectural decisions that happen during programming, leaving developers with less confidence in edge cases and design fit.
• LLM-generated code may be technically plausible but still generic, ugly, poorly integrated with local style, or weak on long-term maintainability.
• Heavy review loops can become a wash or worse on time, especially when the developer could have written the code directly with better understanding.
• AI workflows can create cognitive debt, anchoring, dependency, and reduced satisfaction because supervising generated work feels different from being in coding flow.
• Short-term productivity stories may be masking future maintenance costs, brittle implementations, or code that merely satisfies tests without reflecting durable engineering quality.