Review-First Programming
Art Criticism by H.Daumier
Summary
Food critics who can't cook at Michelin level. Editors who don't write novels. Casting directors who can't act.
Different skills, not lesser skills?
LLMs are revealing something we usually sweep under the rug: generation and evaluation are cognitively asymmetric. Research on utterance planning shows construction is harder than execution. Starting with nothing costs more cognitive load than refining something that already exists.
This phenomenon isn't new. "Real Programmers Don't Use Pascal" (1983) mocked structured programming as "quiche eating." Every abstraction faced resistance from people who valued control over leverage.
Review-first programming isn't a decline. It's specialization. And the developers adapting fastest aren't the ones who generate the most code. They're the ones who know what not to build.
Many developers using LLMs find they're better at reviewing code than writing it. At first that sounds like an admission of incompetence. But what if it's not? Perhaps it's a recognition of how different cognitive skills work.
The Cognitive Architecture
It's hard to write code from scratch. You have to deal with syntax, design patterns, edge cases, and architecture all at the same time. It's like trying to hold multiple conversations simultaneously. Reviewing code is simpler. You look at what's there and ask one question: Does this solve the problem correctly? This explains what I've heard from a number of developers: they feel more capable reviewing LLM-generated code than writing their own.
Some worry this means they're becoming worse programmers. I don't think it's necessarily true. They're becoming different programmers.
Generation vs. Evaluation Asymmetry: Writing code takes a lot of brainpower. When you review code, you can just focus on making sure it's correct. But this isn't a limitation; it's how human cognition actually works.
Research on language production shows that utterance planning can be "more demanding than speaking itself." The asymmetry explains why evaluation feels easier than generation.
The Blank Canvas Problem: Starting from scratch is cognitively expensive. Even developers with a lot of experience copy and paste their own code as scaffolding. LLMs provide infinite scaffolding. This lets you focus your energy on what matters: correct logic, sound architecture, good judgment.
The Skill Transformation
When you review LLM code, you're figuring out what the author meant by looking at the artifacts. You're reasoning from first principles. You're keeping the architectural coherence of parts you didn't write. This might need more knowledge than regular programming.
This parallels earlier shifts in programming. In 1983, Ed Post published 'Real Programmers Don't Use Pascal' in Datamation, contrasting assembly and FORTRAN programmers with 'quiche eaters' who used structured languages. Every new abstraction layer since has faced similar resistance from programmers who valued the control and performance of lower-level languages. Each generation was right in some way: something was being abstracted away. But the best programmers at each level knew how to work with the layer below regardless.
The developers who will have a hard time with this change are the ones who see themselves as creators rather than curators. But the best editors often understand deeper principles than the best writers. They just express that understanding differently.
The Benefit of Scalability
A developer who can review and direct runs multiple LLMs at once, spinning up approaches, comparing outputs, iterating faster. They are conductors, not performers.
Tools for orchestrating multiple coding LLMs let developers use different models' strengths: specialized models for different languages, frameworks, or problem types. This conductor model amplifies the review-first approach.
LLMs generate perfect syntax but don't know when not to use it. They'll implement distributed systems when a single process would do. They'll create elegant abstractions that become maintenance nightmares. The expertise is knowing what not to build.
LLMs invert the traditional constraint. Generation becomes cheap. Good judgment becomes scarce.