If you stop writing code, you also get worse at reviewing it
theanonymousone
334 points
165 comments
November 20, 2026
Related Discussions
Found 5 related stories in 141.3ms across 13,334 title embeddings via pgvector HNSW
- Reviewing code you didn't write colescodes · 14 pts · July 22, 2026 · 68% similar
- I stopped reviewing my agents' code. Here's what I do instead alexeyindeev · 12 pts · October 04, 2026 · 65% similar
- Maybe We Shouldn't Be Reviewing All This Code ingve · 40 pts · September 02, 2026 · 60% similar
- Writing code by hand is over, forever aray07 · 21 pts · October 03, 2026 · 57% similar
- There's No Limit to How Bad Code Can Get zkehs · 100 pts · September 05, 2026 · 57% similar
Discussion Highlights (20 comments)
jqpabc123
In other words, AI creates a self degrading and ultimately defeating feedback loop. It works to supplant/eliminate those who produce the quality data (aka well written code) it needs for training. AI trained on AI slop can only get sloppier over time.
jghn
This must be why I keep getting told by people that it's better to offload the reviewing to the agents as well.
boramdd
This just reminds me a quote from Filippo di Strata, a scribe in 15th century. "The pen is a virgin; the printing press is a whore."
bemtevi
That's obvious. People claim they understand every line of code their agents write, but there's understanding...and then there's understanding. A cursory idea of how code works does not mean the same deep understanding of the solution nor does it give the feeling of the 'lightbulb' when a thorny problem is solved. For a long time in coding, we've constantly been piling on technical debt, even before AI. With frameworks, layers, etc. But AI is a quantum leap that makes the problem far worse. Note that compilers that go from C to assembly/machine code are a lot different because C for instance (or Rust, Python), etc. still exposes all of the core abstracted logic. AI does not. It hides the logic. In the future, no one is going to understand much of anything except a few who will command vast AI infrastructures that will just attack each other, because the attack surface will just have multiplied to a point that bringing other people down is far more lucrative than doing anything else. It's all so obvious and yet we continue on.... a sad state of affairs for programming. AI is a bad thing indeed....
bluGill
There are plenty of coaches that are not great at the game they play. Some of them never were even good. The ability to tell someone how to do something is not the same as being able to do it. Reviewing code and writing code a different skills. They are related, but they are very different.
snailcoder
What about the code you were never able to write because you were time constrained? I have learned so much about the devops process through Claude and ansible playbooks and terraform that I would’ve never known was possible because of a lack of time. I do agree we can’t shut off our brains. But a good bit of software dev was taking the time to go through documentation to understand specific syntax or what was possible with a certain type of tooling. I’m okay with automating the mundane and having much better software using the latest infrastructure and libraries. This all comes with tradeoffs, but I just don’t buy the “autopilot” argument. I’ve learned more in the past year than any year prior in technology. All this learning is now possible, because I’m not spending my time wiring a react front end to a backend for a simple table crud operation.
gosen
Yes and no If "writing code" is a craft then not writing it would result badly reading it, true. But I disagree that software engineering is a "writing code craft", it contains much more (designing system, architecture, testing, requirements and spec design, etc.) so all these things stayed with AI agents writing the code, and also software engineering craft expanded with new workflows and kinds of problems with AI. So getting worse at reviewing the code might be somewhat expected outcome in that change, we'll see over time
bengold14
I think most people at this point just don't review code. Which is a shame, because: 1. It was good for collaboration. Sharing how you are changing the codebase pushes everyone to row in the same direction, and provides a sense of team ownership. 2. It was good as a push for engineers to take pride in their work. Knowing someone is watching gives you subconsciously an extra reason to not cut corners. And when you spend effort not cutting corners you expect that in your teammates, which is a (potentially) virtuous circle. 3. It was good for catching mistakes. When code was expensive this was important. Everyone thinks of code review as primarily relevant for 3, and since code is no longer expensive they think it is unimportant and you can skip it. But 3 isn't dead, its importance has just shifted from code to architecture. It is still an expensive mistake to screw up architecture and have other engineers build upon that flaw. Re-architecting with live users, data and/or hardware is not as simple as fixing a code bug, and it deserves attention to catch mistakes. Collaboration & pride are also still important. This is the reason that instead of stopping review, we need to change what abstraction we review. Code is no longer the right tool for understanding applications in most cases. (disclosure I work in this space and run https://www.archme.io which is working to solve the above)
edg5000
I don't need to review to tell if it's good, but I do need to read the code direct style, architecture, composition. It's not going to make mistakes, just not do what you want it to. It's a gun that shoots out beautiful code, it's just a bit hard to aim from time to time :D
piskov
There’s too little time passed for this to be known definitively. Then again, pilots are mandated to fly manual specific number of hours even though autopilot is a thing. You know, just in case. Same should be applied here if one is on the cautious side.
j45
Can it make the inverse true sometimes? The more you write code, the more some of your code might not need review? While thats kind of a joke, I think there are developers who learned to code by reading (review) existing code. Maybe this will have to evolve for the age we're in.
cgarvis
I always saw code reviews as a step to get everyone aligned to the same "Mental Model" of what the system does. It caught bugs and was an opportunity to mentor. But really it was for the reviewer to either update their mental model or correct yours. The job of the software engineer is to interface with the world, create a mental model of that world, and then make software that matches. That hasn't changed. We are still figuring out what the new best practices are given there are less people to align.
prxtl
OT but the combination of line height and font size on the website makes the article so uncomfortable to read!
sceptic123
I don't think the analogy holds, it sounds like he's describing musicians that become producers. It's not the same job, and you don't have to have been a musician to do the job, but having been a musician, you have an insight into the music-making process that can help you be better at producing other people's music. Taking that analogy further, there are some fantastic producers who are terrible musicians. Perhaps that's the bigger worry, you don't need to be good at writing code to be able to produce it any more.
JamesLeonis
I agree with the author we're in a weird moment where the Best Practices seemingly flipped. Five years ago it was common knowledge on HN that moving away from the code (like taking a management position) atrophied your programming skills. The routine suggestion was to get your hands dirty again. AI-first folks will tell me I should see my new responsibility as being just such a manager over little agent kiddos running around. However I can turn a flesh-and-blood Junior/Intern developer into full independent developer I can trust with more complex tasks. I can't do that with AI. I previously made the observation [0] that the AI talk mirrors the Outsourcing talk from the early 2000s. I have a terrible feeling we are going to learn these bitter lessons all over again. [0]: https://news.ycombinator.com/item?id=47125477
fusslo
We've stopped reviewing code for code's sake. We review code to keep the codebase clean and consistent. Before agentic development, the cost was large for changes at the review stage. Often the person writing the code didn't have the right context or experience to make the best choice. So reviewing would often blow up a pull request. Which sucked. Eventually every engineer would have AI generate a PR. People would review, blow it up, and the engineer would copy/paste the feedback into AI to generate another PR. But now, we use reviews to enforce design decisions and get feedback from the other people who couldn't be involved in the initial design (for example if a new feature interacts with a module owned by another team). The actual nuts-and-bolts of how the code is written is mostly unimportant. It was a large mentality shift for the company We spend LOTS of time on the design, verification, testing. The verification and testing is built first. Agents take the input of the problem, design document, and current codebase to generate code. It iterates by running the verification tools. Then it runs the testing tools. The better we make the tools for AI, the better the product code is. We've automated gathering power readings, timing reports, wifi/ble sniffing, smoke tests, feature tests, corner cases, robots for pressing buttons, static analysis tools, unit tests, customer styled system tests... tools to emulate cell phones, servers, etc...
frenchsalmon
Agree with the author, although reviewing the code is also something that we are doomed to stop doing. At one point, we are too much in the way of our agents. The point of AI is to break bottlenecks, so if the bottleneck becomes the review, then the review is soon to be gone. Note that I don't particularly enjoy this, more like realizing what's hapenning at my scope.
danieldrehmer
if you stop writing assembly, you also get worse at manual compilation
bitwize
The good news is, agents are getting better at reviewing it. So you can just delegate that bit to them. Maybe not completely, not yet, but more and more with each model improvement.
K3UL
I have been raising this point in my company (which targets almost zero human code) but the answer is almost always about tooling and more AI-review. It's like talking to a wall. So personally I have been fighting this by going all in with personal/side/shadow projects whenever I find the time, and adjusting my manual coding in them as I see fit