🌱 Dive into Learning-Rich Sundays with groCTO ⤵️
Article of the Week ⭐
“Though I was code review’s biggest fanboy in 1998, I’ll now try to convince you they’re impracticable, and will soon be downright irresponsible.”
Philip Su has a provocative claim: code reviews are becoming impractical to the point of being outright irresponsible. And he’s not being hyperbolic for effect. Let’s look into the math and ideas that he used to back up his claim.
AI assistance produces 5-20x leaps in the production of code changes that leaves the human reviewers as a rather obvious bottleneck. The process becomes a fiction and no amount of “@codex fix this,” makes the quality gate that was meant to teach the author something new rather tedious and dangerous.
Su’s framing reaches back to his early career. As a 22-year-old at Microsoft in 1998, he was code review’s biggest evangelist. Scheduling meetings with senior managers to pitch mandatory reviews, arguing for the knowledge transfer, the error-catching, the shared understanding of the codebase.
He didn’t win that argument then and his point now is that the argument has become moot in the opposite direction: not that code review was never valuable, but that the volume of AI-generated code has made it structurally impossible to sustain.
His vision for what comes next is what he calls a lights-out codebase. Named after lights-out data centers, fully automated facilities where no human ever walks the floor and lighting isn’t even necessary. In a lights-out codebase, no human ever sees the code. Not as a distant aspiration. As the logical endpoint of dynamics already clearly in motion. Sounds too good to be true. Is it?
His two most recent apps were built entirely without him viewing or editing a single line of code. From creating the GitHub repo all the way through releasing to production, the experience hasn’t made him entirely comfortable, but it’s a sign in the right direction. The AI reviewers caught a surprise amount of bugs in code he’d already pre-reviewed and signed off on himself.
Not only can AI can keep up with AI-generated code, but he and his team may have been worse at reviewing code than they were prepared to admit. Afterall, humans can get biased, get put under time pressure or have to triage their attention. Something an AI reviewer does not suffer from, as long as it receives reasonable care and maintenance from human operators. And we’re only finding out now that there’s something better to compare against.
What replaces human review? A layered system of AI checks:
TDD-style component boundaries: testable seams that force structure and accountability before a line of code is written
AI reviewing AI: pre- and post-action reviews, once before a plan executes and again after coding completes
Multiple LLMs cross-checking each other: different models with different strengths covering each other’s blind spots
Dedicated specialist agents: a security agent that only looks for security issues, rather than a generalist reviewer trying to catch everything
CI/CD protections and pre-commit hooks: automated gates that enforce quality standards before anything lands. The bread and butter, though not new for AI-era software.
None of this is entirely new, Su acknowledges. TDD, automated testing, CI/CD pipelines have been known best practices for years. What’s changed is their urgency. When AI is producing code at a volume no human team can manually review, the layered safety net stops being a nice-to-have and becomes the only viable architecture for quality assurance.
The analogy he reaches for is autonomous driving. Waymos cause five times fewer injuries than human drivers on the same urban roads. And yet adoption remains slow, because it doesn’t feel believable at a gut level. We move goalposts. We reach for edge cases. We find what-about-isms. And in the meantime, more accidents happen than necessary.
Su thinks software is heading the same direction, on a similar timeline. The rational case is already there. The gut feeling hasn’t caught up. But one day, he argues, people will be genuinely aghast to learn that their mission-critical cloud platform “lets humans touch the code.”
Software organizations were never primarily limited by how fast engineers write code. The real constraints fall onto product decisions, business trade-offs, organizational structure, and engineering judgment among others. AI dramatically accelerates code production, which was already the cheap part.
Emmanuel Valverde Ramos explores some of the frictions with agentic software:
Product decisions: understanding real user problems, especially prioritizing under uncertainty
Business trade-offs: ROI versus reliability versus long-term quality
Organizational structure: Conway’s Law in action; fragmented teams produce fragmented architecture
Decision latency: code takes minutes to write, but the decision justifying it can take weeks, and validation months
His evidence is pointing at the 2025 DORA report which found AI increases delivery throughput and delivery instability simultaneously.
Another benchmark called SWE-CI tested AI agents on 100 real codebases across 233 days each. They failed to maintain system integrity over time.
Amazon held mandatory internal briefings about high-blast-radius incidents linked to AI-assisted changes.
An Anthropic study sharpens the concern: developers using AI scored 50% on a debugging quiz versus 67% in the hand-coding group. The skill most impaired was exactly the one needed to handle outage-related incidents.
The broader implication draws on Bainbridge’s Ironies of Automation: humans remain responsible for the hardest moments even as automation absorbs routine work. The skills required during incidents are built through wrestling with systems and their complexities, not through approving generated output.
When implementation gets cheaper any bad decision scale their output into the downstream bottlenecks, making them more expensive to optimise. AI amplifies whatever engineering culture already exists, with a vocal majority echoing concerns and weak discipline in equal measures.
The tools available in your PATH directly affect what your AI coding assistant can produce. Most engineers haven’t optimised that environment for the agent, prioritising ergonomics mostly for themselves.
Derosiaux tested this by asking Claude Code directly: “What tools are you missing to work effectively on my machine?”
The agent spun up parallel subagents, swept through every binary in PATH, parsed Homebrew packages, inspected shell aliases, and returned a prioritized report.
The recommendations split into four categories:
Speed and navigation —
ripgrep(gitignore-aware grep),fd(modern find),fzf(interactive filtering). Shorter commands mean fewer syntax errors and less wasted context window.Structured output —
git-deltamakes diffs parseable with line numbers and clean section boundaries.xhseparates headers, status codes, and response body when testing APIs.Automation —
watchexecreruns commands on file changes, eliminating polling loops.justreplaces Makefile boilerplate for task running.Deterministic analysis —
semgrepshifts security review from “the AI thinks this looks like SQL injection” to a flagged rule with a specific line. That distinction matters when you’re validating AI output.
The surprise entry was DuckDB: a 30MB binary that lets the agent run SQL directly against CSV, Parquet, or JSON files. Without it, data analysis means writing throwaway Python scripts. With it, one query.
We set up laptops for new engineers with IDE, extensions, credentials, environment files. Nobody questions that, but the same logic applies to the agent writing code alongside them. Their tooling requirements just happen to be different and sharing the same environment.
If you use Nix flakes or dev containers, this setup can be version-controlled and shipped with the project. The AI’s preferred environment becomes a first-class artifact.
That’s it for Today!
Whether you’re innovating on new projects, staying ahead of tech trends, or taking a strategic pause to recharge, may your day be as impactful and inspiring as your leadership.
See you next week, Ciao 👋
Curators - Diligently curated by our community members Denis & Varun
Featured Authors - Philip Su, Emmanuel Valverde Ramos, Stephane Derosiaux
Sponsors - This newsletter is sponsored by Typo AI - Engineering Intelligence Platform for the AI Era.
1) Subscribe — If you aren’t already, consider becoming a groCTO subscriber.
2) Share — Spread the word amongst fellow Engineering Leaders and CTOs! Your referral empowers & builds our groCTO community.
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.