[KongchangAI]
· 2 min read· 1,264 words

Stop Writing Code and Your Code Review Skills Will Degrade Too

Stop Writing Code and Your Code Review Skills Will Degrade Too

Stopping hands-on coding weakens review skills; in the AI era, reviewers become the quality bottleneck.

The article centers on cekrem's blog view that "if you don't write code, you can't review it well," pointing out that code review is not pure reading but depends on simulated execution ability and tacit "feel" trained through long-term coding—both share the same judgment. When developers only review without writing for a long time, sensitivity to deep traps declines. As AI-generated code spreads, the coding link is compressed and the review link amplified, so reviewer ability directly determines the quality ceiling of delivery, and its degradation signals are often subtle—shorter review times, fewer boundary questions, and looser approval of complex changes. The article suggests retaining hands-on writing of core logic, fixing bugs, independent rehearsal before review, and small-scale experimental coding to keep judgment sharp.

A Counterintuitive Observation

As AI coding assistants become increasingly widespread, more and more developers are shifting their focus from "writing code" to "reviewing code." This sounds like the natural result of an efficiency upgrade—let machines generate the first draft, and humans handle quality control. But in his personal blog post "If you stop writing code, you also get worse at reviewing it," cekrem raises a point worth heeding: stopping writing code by hand also weakens your ability to review it.

This post earned 324 points and 159 comments on Hacker News, showing that it struck a nerve with an anxiety widespread in the developer community. This article does not rely on specific experimental data, but rather starts from the core arguments of the post and combines them with experience from engineering practice to explore the hidden connection between "writing" and "reviewing."

rss source: If you stop writing code, you also get worse at reviewing it

Writing and Reviewing Share the Same Judgment

Code Review Is Not a Pure Reading Activity

Code review is often misunderstood as a "reading + error-spotting" activity. But truly experienced reviewers know that high-quality review depends on a kind of simulated execution ability: when you see a loop, your brain automatically works out the boundary conditions; when you see a state update, you instinctively ask what will happen under concurrent scenarios.

This simulated execution ability is precisely trained through years of hands-on coding. The original author's core point lies exactly here: the judgment used in review and the judgment mobilized when writing code are the same set. If you don't write, this muscle doesn't get exercised.

"Feel" Is Tacit Knowledge That's Hard to Outsource

What accumulates during coding is not just syntax memory, but also a large amount of intuition about "where things tend to go wrong." For example, you know under what circumstances the return value of a certain asynchronous interface is undefined, and you know when a certain ORM's lazy loading will trigger extra queries. This knowledge is hard to obtain completely by reading documentation; it comes more from the process of hitting pitfalls and fixing them.

When developers only do review for a long time, this firsthand "feel" gradually dilutes. During review you may still be able to spot obvious style issues or naming issues, but your sensitivity to those deep traps that only surface when you actually do the work will decline.

"Tacit knowledge" was proposed by philosopher Michael Polanyi in Personal Knowledge, referring to knowledge that is difficult to fully express through language, formulas, or documentation, and can only be transmitted through personal practice and mentor-style demonstration. He has a famous summary: we know more than we can tell. The "feel" in programming is a typical example—it's hard to write clearly in words why this loop goes wrong on the third element, but anyone who has debugged it by hand will immediately be alert. This contrasts with "explicit knowledge" (syntax rules, API documentation). The reason the degradation of review ability is so insidious is precisely because what's damaged is tacit knowledge: reviewers can still read code and state the conventions, but they have lost that bodily memory of specific traps that is only activated when doing the work.

The Amplifier Effect in the AI Era

The Reviewer's Ability Becomes the New Bottleneck

With the spread of AI-generated code, the "writing" link in teams has been greatly compressed, while the "reviewing" link has been multiplied. This means the upper limit of the reviewer's ability directly determines the upper limit of the quality of delivered code.

The original article's observation here carries considerable weight: if reviewers' own judgment degrades because they haven't written code for a long time, then AI-generated code is more likely to slip through. On the surface the process is still running and review is still happening, but the actual quality gate has loosened.

The "bottleneck" idea can be understood through the Theory of Constraints: the throughput of any process is determined by its slowest link. In traditional development, coding speed is often the bottleneck, and review is relatively abundant; when AI greatly speeds up the coding link, the process's overall capacity shifts to the review link. At this point, adding more generation volume won't improve delivery quality—it will only make more unreviewed code queue up. More critically, review as a quality gate has asymmetry—the cost of missing one serious defect is far greater than the cost of spending more time reviewing. Therefore, the degradation of reviewers' judgment is not just a personal ability issue, but a systemic risk that directly lowers the quality ceiling of the entire team.

The Signals of Review Degradation Are Often Subtle

Declining review ability isn't as conspicuous as a compilation error. It manifests as: shorter review times for complex changes, a tendency to let "seemingly reasonable" code through, fewer questions about boundary conditions, and skipping unfamiliar code areas altogether. Individually none of these signals seems like a problem, but cumulatively they mean the entire team's code quality defense line is quietly retreating.

This "subtle signals" phenomenon can be compared to "boiling frog"-style gradual degradation: ability decline has no threshold alarm, but is reflected through a series of micro-behavioral shifts. The "cognitive miser" tendency in cognitive psychology also provides a reference—when the brain lacks sufficient familiarity with a certain type of task, it instinctively chooses the least effortful heuristic judgment (such as "let it through if the code looks reasonable") to reduce cognitive load. If reviewers don't code by hand for a long time, their perception of change complexity becomes inaccurate, triggering this low-effort mode earlier. Identifying these shifts requires establishing observable metrics at the team level, such as the distribution of review durations, the number of boundary-condition questions raised in comments, and the proportion of changes that were let through but later exposed defects.

How to Maintain the Ability to "Write"

Completely rejecting AI assistance is neither realistic nor necessary. A more pragmatic direction is to retain a certain proportion of hands-on coding, especially for those links that demand high judgment.

Specifically, you can deliberately involve yourself in the following types of work:

  • Core logic and boundary handling: Try to write code involving state machines, concurrency, and error recovery by hand, because the risks of such code depend most on intuitive judgment.
  • Defect fixing: Fixing bugs is the most efficient way to rebuild the intuition of "where things go wrong," and is more valuable than reading a hundred lines of normal code.
  • Rehearsal before code review: Before reviewing a complex change, first independently write down the implementation approach yourself, then compare it with the submitter's solution—this comparison itself is exercising judgment.
  • Small-scale experimental coding: Use personal projects or prototypes to maintain your feel; don't pursue output, but focus on maintaining familiarity with the language and toolchain.

The original author emphasizes in the article the irreplaceability of the act of "doing the work." This advice, after AI-assisted programming becomes the norm, is actually more practically meaningful, not less.

Conclusion: Treat Review as an Extension of Writing Code

The saying "if you don't write code, you can't review it well" seems counterintuitive, but it points to a plain fact: review ability is not an independent skill—it grows on top of coding practice. AI can share the output pressure of coding, but it cannot replace the judgment developers accumulate through hands-on coding.

For developers who have already handed most of their coding work to AI, it may be necessary to reallocate a little time back in front of the keyboard. Not to produce more code, but to keep your reviewing eye sharp.

#code review#AI coding#tacit knowledge#developer skills#programming practice
Share:

Related articles