logoalt Hacker News

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

294 points • by theanonymousone • today at 12:41 PM • 141 comments • view on HN

Comments

JamesLeonis • today at 3:58 PM

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

➕ show 7 replies
bengold14 • today at 3:18 PM

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)

➕ show 4 replies
jarjoura • today at 6:39 PM

Our profession was built on (from its very inception) and is entirely staffed with people obsessed with speed, efficiency, and correctness.

For us, it's so core to our nature that when some new tech promises all 3 in one, most of us can't help but dive in full steam and not question it.

The fact that Anthropic can so easily go around to tech companies and sell them on "coding has been solved," and "we just throw more AI at the issues our AI creates" without anyone normally skeptical of marketing is the wildest most surreal experience I've had on the ground floor.

There are actual engineers, people who went to university, who now equate prompting as just a new higher-level programming language and the code it poops out as the "new assembly language."

Normally organizations depend on their super senior engineers (a particularly powerful minority of folks that were promoted because they figured out how to scale themselves) to help guide decisions, but they're the ones most empowered by this shift because it unlocks even more scale for them. The juniors feel empowered because they can take on projects usually reserved for senior engineers and actually deliver on it. Everyone else is just caught in the middle, neither helped nor hurt by the shift, but also mostly fine if we rolled back most of this.

This is the first time I've seen something so pervasive, mentally break people, to the point we now seem okay with turning core IP into black boxes.

➕ show 1 reply
snailcoder • today at 2:34 PM

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.

➕ show 4 replies
bemtevi • today at 2:05 PM

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....

➕ show 1 reply
t43562 • today at 8:36 PM

IMO its when you don't understand the codebase and the problems it's dealing that your reviews become trivial and non valuable. You end up focusing on trivialities which don't matter. I became a team lead in my last job and that's exactly what happened to me.

Just as we don't care too much about how AI does the little things, one has to make space for human engineers to be different from each other and from oneself. I felt I wasn't delivering much value by asking "did you use a list comprehension" or even the spotting of small mistakes. The value I needed to bring was a level up - whether the change hangs together logically with the rest of the codebase and whether the tests really test that and how will this fit the requirement or complicate the future.

As a non coding manager I could still program but I really didn't understand the technical problems my team was facing in the codebase until I got in there and learned it by doing work. It was very difficult to do this while doing the management side of things that eat up time - like hiring people or trying to extract the actual requirements from the wider business but in the end I was able to shelve some of that and get back to code which turned out to be essential.

When I understood the technical problems I could plan and make reasonable team lead type decisions. I could also give my management better information too which they obviously didn't like because it was about things like "that's logically nonsensical and therefore technically impossible."

fusslo • today at 4:06 PM

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...

➕ show 3 replies
gwbas1c • today at 4:45 PM

There's a certain engineering mindset that AI doesn't replace.

For example, yesterday it appeared that some AI changes made a regression. I spent more time going back and forth, trying to "fix" the regression, than the initial prompt. It took traditional problem solving skills to figure out that the regression happened before AI's changes, and how to reproduce the regression.

cgarvis • today at 3:38 PM

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.

drusepth • today at 7:28 PM

It is weird to see this take a form opposite reading-writing (which seems like a parallel): it's pretty well-established that reading has a major impact in making you a better writer, not the other way around.

Interesting that reading code seemingly doesn't have the same effect on writing it, according to this author at least.

4ndrewl • today at 8:11 PM

"There’s more to software engineering than writing code"

There really isn't. There may be more to shipping products than writing code, but in organisations of any size that's been specialized into different, other, roles for decades.

brokegrammer • today at 5:27 PM

One thing I realized since I stopped writing code is that code review is mostly useless if AI is going to be managing your code base. Instead, I've been focusing on business rules, functionality, and security. If your data structure looks like it should, your UI works properly, and your security holes are patched, then having a human review code is a waste of time.

➕ show 2 replies
bluGill • today at 2:33 PM

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.

➕ show 1 reply
abalex • today at 6:40 PM

If you want to be a good driver, you need to learn how to drive and control speed car, and no need to watch how service change the oil and fix something under this car... More important learn how to give a correct tasks, than review each line and spend more time than self hands development. You need to choose, to be a mechanic or to be a driver, no need to learn both. But of course you need to understand how your project works and control AI to keep right direction.

gosen • today at 2:35 PM

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

➕ show 2 replies
Kuyawa • today at 5:43 PM

I haven't coded a single line this year and I still recognize the beauty in Donald Knuth's Sudoku solver

There is nothing else to learn, nothing else to appreciate, and nothing else to review

boramdd • today at 1:39 PM

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."

Overdrivr • today at 5:46 PM

IMO what's bad is not reviewing code in less depth and being less sharp at reviewing it at a low level. It's the fact that engineers are also delegating their thinking to LLMs, especially critical product and tech decisions around a feature. And this is really bad because very fast nobody is able to explain how the system work, its tradeoffs, explain certain observed behavior when final users ask questions and so on.

euph0ria • today at 7:20 PM

Not arguing against the post but trying to find counterexamples: Does a book editor need to be an author as well in order to be a great book editor?

thatxliner • today at 4:35 PM

It's because we think with "intellectual" skills there's nothing to atrophy as you could derive/figure out your way out again.

But then people forget you can still "get rusty" from not playing chess in a while.

pianopatrick • today at 4:31 PM

If the AI keeps getting better exponentially who knows what will make sense to do in a year or so. Maybe the AI will be so obviously good at reading, writing and reviewing code that almost no one will do so themselves any more. Maybe the AI will get so good at all the other tasks that we can have the AI do most of the other steps we say AI cannot do right now. Or maybe the AI stalls out and stops getting better. I would not count on that though.

➕ show 2 replies
ginthian • today at 7:36 PM

I tested systems for years and done programming myself. A friend of mine talked about the use of AI making programmers bad at programming because they are not doing the code. I agree, if you don't do the code then reviewing the code will be more difficult.

sceptic123 • today at 3:49 PM

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.

➕ show 2 replies
kstenerud • today at 7:59 PM

I just did a live coding interview today. It didn't go well.

I have 30 years professional experience, and 40 years total experience in software engineering. I started with assembler, then to C, then moved on to work in almost every popular language there is.

Last year I started working with AI. I've now gotten to the point where I can build huge, complex systems that would have been an impossibility for a single person before (short of investing decades into it). It's truly an amazing lever.

And then I did a live coding interview today. You know the drill: pick a language, talk about some problem that involves some kind of vaguely tricky algorithm you need to figure out, then code it.

Well, coming up with the algorithm, discussing the tradeoffs in time and space complexity was no problem, but then when I went to code it, I felt a very familiar feeling.

I still remember back in the day when I had to go back to assembler for something after coding in C for a couple of years. It was PAINFUL. It was SLOW. It felt so utterly MORONIC to even be writing an app entirely in assembly in that day and age of compilers that did a pretty damn good job without the slow, torturous pain of tracking registers, PC-relative addressing, stack pointers and all that junk.

Today was a mirror of that. The first thing going through my head is "Why the fuck should I be fighting over the proper syntax to write a fucking loop?" "Why should I have to remember all these damn Python footguns?" "Why should I be trying to remember if it's var x or <type> x or x: <type> or x := something or any of the crazy ways I've written it over the years depending on the language??"

My velocity was so slow it felt like I was walking in molasses. My thought flow was jagged and irregular as I fought for every line of code, trying to decompose the algorithm in my mind into primitive steps, just like it felt when I went from C to assembly that day. It just makes no sense to write code this way!

I probably won't get the job, but I also realized that I probably don't want a job that doesn't embrace AI assisted software development the way I do. I don't think I could handle working that slow again, even if the pay is great.

K3UL • today at 4:20 PM

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

➕ show 1 reply
frenchsalmon • today at 4:07 PM

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.

jghn • today at 1:34 PM

This must be why I keep getting told by people that it's better to offload the reviewing to the agents as well.

➕ show 2 replies
hmokiguess • today at 4:46 PM

Tangential, but I find this title almost comical. It reminds me of a conversation I had with a friend once.

We both do rock climbing and gymnastics, and one day, while we were climbing, this person approached my friend (who is a great climber, and newcomer into gymnastics) and asked:

- "Hey Dude, I noticed you're now doing gymnastics! That's sick! Do you find it helps with climbing?! You must be a lot better now because of it eh!".

My friend then responded pretty seriously and blunt:

- "No. More climbing helps with climbing."

I still laugh about it every time I remember it.

Anyways, all this to say that I think it's quite obvious that you need to practice the thing to do the thing and only doing the thing is doing the thing. [1]

[1] https://strangestloop.io/essays/things-that-arent-doing-the-...

jjak82 • today at 4:44 PM

BTW I built https://stayleet.com for related reasons to this. When AI is doing more and more, skill maintenance is an issue. Coding is only a part of it (albeit pretty significant part.)

dust-jacket • today at 4:36 PM

The analogy here is pretty ropey IMO.

Yes, a guitar player should not expect to just stop playing guitar because they're good enough but equally... a composer does not need to be able to play each of the instruments they compose for.

➕ show 2 replies
edg5000 • today at 3:31 PM

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

charlieyu1 • today at 4:55 PM

I wrote my first code for a while today because the model is taking forever for a simple task. I finished the code and still haven’t got a response from the model. Maybe I should write more.

0xbadcafebee • today at 7:47 PM

Provably false, otherwise architects couldn't exist. They would never be able to review anything if they didn't write code (or construct buildings) 24/7. Your ability to write code has almost nothing to do with your understanding of it.

There is a difference between building a thing, maintaining a thing, and understanding a thing. You don't have to do any of the one to be able to do the other.

fph • today at 5:25 PM

When I read the title I hoped this would be a scientific study with solid stats, but no, it's just some dude's opinion.

piskov • today at 3:33 PM

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.

➕ show 2 replies
rsyring • today at 5:28 PM

One thing I've noticed about engineers, and I don't see talked about as much, is that code review is, IMO, and intrinsic skill. Some of us are wired to do it much better than others.

I personally hate code reviews and don't do well at it. But, I'm arguably really good at writing clean code that works well and is easy to maintain for the long haul.

I used to have a guy that worked for me that was on the lower end when it came to how he wrote code. But, he was absolutely great at code review.

With AI, I'm finding some of our engineers seem to be much better at code review and adapt their AI interactions accordingly. Namely, they do bigger chunks. Those who aren't as good tend to prefer much smaller chunks.

Interestingly, we had a project get out of hand with AI slop and I did an AI write moratorium. They could use AI to grok the code, develop ideas, and generate small code snippets they could then copy into the app's files, develop them further, and wire everything in. Importantly, AI could not write to any file directly. Obviously, this can be gamed, but they were open to trying it and it worked wonders for that project.

I suggested trying that for our entire org and I had one of my very good high quality engineers, who seems to be good at reviewing code, strongly object to it (with some good reasoning).

prxtl • today at 3:44 PM

OT but the combination of line height and font size on the website makes the article so uncomfortable to read!

seki285 • today at 5:08 PM

What are the implications surrounding Linus Torvalds and other folks

nsxwolf • today at 7:05 PM

Haven't we begun to stop reviewing it too?

IncreasePosts • today at 4:33 PM

For years we accepted "principal engineers" designing our systems who haven't written a line of code in 5 years, and all of the sudden now it's a problem?

➕ show 1 reply
danieldrehmer • today at 4:17 PM

if you stop writing assembly, you also get worse at manual compilation

vcryan • today at 5:07 PM

The premise seems odd to me.

1. If a person can devise a method of using AI for generating code why can they not devise automated methods of reliably verifying code?

2. I guess we can create a new job title of professional code reviewer - but without that I don't know how teams would keep up with the volume of code review when someone can open 10-100 PRs per day.

3. Do we believe human are good at code review, generally? I do not. When AI or other automated approaches are compared to humans reviewing code it seems like the comparison is towards this idealized amazing accurate human code reviewer but in our experience - such people exist - but they are far outnumbered by careless code reviewers.

Probably obvious from my comments - but I'm not planning to read much code anymore in my career. Seems like a waste of time when it can be generated and verified (adequately) through various automations. I understand that good verification doubles or triples the time of generating code - still way way faster than people being directly involved.

RomanPushkin • today at 6:12 PM

== "If you stop writing code, you also get worse at what no one is doing today anyway"

bitwize • today at 4:20 PM

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.

j45 • today at 3:36 PM

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.

➕ show 1 reply
jqpabc123 • today at 1:05 PM

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.

➕ show 2 replies
insane_dreamer • today at 4:42 PM

also companies are no longer hiring people to write code (because ... profit!!), so once current sr engineers -> graybeards -> gone

there won't be anyone with technical knowledge to manage the agents; it'll truly be a black box

➕ show 1 reply
wellpast • today at 4:45 PM

I always thought the overemphasis on reviewing code was weird, and code review cultures kind of missing the point.

The most important property of "code" is the code architecture, not the LOCs themselves -- i.e., the functional contracts, interfaces, and coupling between them.

That's what really dictates the ability to manage correctness of the system, its testability, and refactor it into new capabilities going forward.

But code review cultures -- ime -- always focused on the lines of code... "you could make these three lines into one", etc - stuff of interest but not worth the code review time over more important considerations.

AI agents are so good at writing tests, if you can prompt and guide them to good code architecture, it seems to me so much of the game is won w/o needing line by line code reviews.

fredericgalline • today at 5:04 PM

[flagged]

arbor-group • today at 2:59 PM

[flagged]

🔗 View 2 more comments