Skip to content

Using AI to Write Better Code More Slowly

Source: Using AI to Write Better Code More Slowly
Date Published: 2026-05-25
Author: Nolan Lawson

TL;DR

Contrary to the dominant narrative that AI coding tools are "slop cannons" for generating low-quality code quickly, Nolan argues that LLMs are extremely flexible and can be used just as effectively to write high-quality code more slowly. The key technique is multi-model PR review — running several different LLM agents to find bugs, then carefully prioritizing and validating their findings.

The Core Thesis

"But the thing is, LLMs are very flexible. And you can use them just as effectively to write high-quality code more slowly."

Key Technique: Multi-Model PR Review

LLM agents excel at finding bugs, but the real challenge is prioritizing and validating them. The solution: use multiple different models in concert.

The Prompt

"Run a Claude sub-agent, Codex, and Cursor Bugbot to find bugs in this PR ranked by critical/high/medium/low. Once they're all done, review their findings, do your own research to rule out false positives, and write a final report."

Why it works: - The more different models you apply, the fewer hallucinations and bogus bugs - False positive rate is reported as near zero

Bugs found consistently: - Critical security or correctness bugs - Medium-level performance bugs - Low-level comments issues ("this comment is misleading")

The Workflow

  1. Fix Criticals & Highs first — Let an agent fix these with author guidance
  2. Repeat — Continue until no criticals or highs remain
  3. Skip low-value fixes — Skip fixes where "the juice isn't worth the squeeze"
  4. Abandon when necessary — If a PR has too many criticals, abandon the approach entirely

Unexpected Outcomes

  • Finds pre-existing bugs — The process uncovers subtle flaws that existed before the current PR
  • Improves codebase health — Proactive bug-finding strengthens the codebase over time
  • Deeper understanding — "The happy-path of a complex architecture is less interesting than its failure modes"
  • No velocity increase — This is the opposite of the "10x productivity" slop-cannon style

"I find this style of coding to be a more super-powered version of the kind of programming I was already trying to do before LLMs: careful, methodical, quality-obsessed, focused on making things better for the next coder."

Advice for "Vibe Coders"

For developers using agents to write large PRs they barely understand:

  1. Ask an agent to explain how your PR works and how it might fail
  2. Generate documentation — Have it write Markdown docs with Mermaid charts
  3. Use deep review skills — Try Matt Pocock's /grill-me skill until you understand the entire PR front-to-back

"So take a deep breath, slow down, try this technique, and see if you don't enjoy writing better code more slowly."

Key Insights from Discussion

  • Wiping context between sweeps is critical to avoid bias from the first result
  • Using 5–7 different "lenses" running in parallel, then collating, improves coverage
  • LLMs should not be stand-alone tools — enablement and governance must occur simultaneously
  • "An LLM's output is just the first draft. The real work starts with the code review."

Key Takeaways

  1. LLMs can be used to write high-quality code more slowly — the opposite of the "slop cannon" narrative
  2. Multi-model PR review dramatically reduces false positives compared to single-model approaches
  3. The process uncovers pre-existing bugs and improves overall codebase health
  4. Wiping context between model sweeps is critical for unbiased results
  5. The real work starts with the code review — LLM output is just the first draft