Reviewing the diff won't save you once you stop writing code
Details
- Published
- Language
- English
- Reading
- 5 min
Christian Ekrem argues that if you stop writing code you get worse at reviewing it. My take, as someone who uses Claude Code and reads every diff first.
The agent has the change ready and the patch is in front of you. If you have not written a line in a while, what are you judging it with?
The question comes from Christian Ekrem. He asked it on November 20, 2026, in a short post: If you stop writing code, you also get worse at reviewing it. By 17:24 ART the next day, the Hacker News thread had 373 points. I read it and I agree with him. This note is how it looks from my own work.

This year's trick
You hear it a lot this year: you no longer need to write code. The job, the idea goes, is now to ask for the change, look at it and accept it, and reviewing is enough.
Ekrem argues the opposite. In almost any craft people take for granted that you get worse when you stop practicing, and software is the one place where some dispute it. He cares little about whether today's output looks good. What worries him is what happens to your skill, some time from now, if you stop writing.
Reviewing is not practicing
He explains it with two analogies. The first is a guitarist who stops playing, gives directions to others and listens to the result. The second is an author who stops writing and, on top of that, reads mostly AI-generated prose. Neither of them keeps the craft.
He also answers the most common objection, that there is more to software than writing code. The objection is right: there is architecture, product and operations. But the code that runs is still a serious part of the job, and if you do not know what a good change looks like or what breaks the design, your review is a formality.
Then he goes further. He says reviewing all the code Claude produced is not enough, and he asks the reader whether, by now, they are really reading it:
at this point you’re not really reading half of it, are you?
Christian Ekrem
The question stings because it is plausible. A long diff gets skimmed and a change that looks reasonable gets accepted. The agent has also learned your style, so the code sounds familiar, and familiar passes for correct very easily.

Reviewing spends the judgement you already have, but it does not train it. If reviewing is all you do, that judgement slowly shrinks.
I still review, and I know it is not enough
I do not think of myself as an "AI engineer". I am a senior who works assisted by AI, and I use Claude Code every day. I give the agent context from my notes, in the terminal. That is why I built Herdsidian, an open source layout for herdr that puts the Obsidian vault next to the agent. I read the note, pass it the context and review the diff before accepting it. I am the one who presses Enter.
When I review a diff I am deciding what goes into the repo, and that decision takes the same judgement I would use if I had written the change myself. Herdsidian helps: I can look at the context and the change without switching windows, and the agent starts better with good notes. I still have to read what came out, because the layout does not review for me.
That judgement depends on me still knowing how to write. If your only contact with code is the queue of diffs an agent produces, you no longer build the solution or run into the edge case, and you arrive at the review with fewer tools than you think. The agent's speed does not make up for it: a badly read change is a bug that reaches the repo sooner.
The hard part is worth trying too
The second half of the post is about another loss. You can argue about how much code you need to write by hand, Ekrem says, but we still solve problems, and the day you stop practicing that you stop getting better at it. In his view, repeated LLM use teaches a habit: if something is hard, tricky or takes effort, do not even try.
I do not want that habit. If I pass context to the agent, it is because I still have to know which context matters, and if I review the diff, it is because I still have to be able to say no.
That is why I still write some code by hand on purpose: a function, a failing test, a hard branch. Claude Code could do it, but I want to reach the next diff with a trained eye.

Some things you only learn when you get stuck: a type that will not line up, a contract that breaks at the edge, a name that seemed clear until you use it a second time. If that friction goes away completely, part of the craft goes with it.
What I am not saying
I am not asking you to drop the agent. Using Claude Code and still writing code go together fine, and the trouble starts the day you stop writing.
I also cannot tell you whether my own review has already got worse, because I do not have that number. I have a practice and a warning that seems fair to me: judgement does not keep itself just because the agent goes faster.
What I take from Ekrem's post
Three things, in my own words:
- Today's output looking good says nothing about your judgement tomorrow.
- Reviewing the agent's work does not replace practicing the craft.
- To stay good at solving problems you have to keep solving them.
Ekrem does not hand over a recipe. He closes by asking us not to stop playing the guitar, which in this job means to keep writing and to actually read the change.
It makes no difference whether you use Claude, Codex or another agent. What matters is whether you can still see what is wrong when it puts a long diff in front of you.
The question
Before you accept the next diff, stop for a second and check whether you are reading it or just letting it through.
And if it has been days since you wrote a line of your own, what do you still write by hand so your review does not become a formality?
Source: Christian Ekrem, If you stop writing code, you also get worse at reviewing it (November 20, 2026). Discussion on Hacker News (373 points as of 17:24 ART, November 21, 2026).
You can also read this note in Spanish.