Hacker News new | past | comments | ask | show | jobs | submit
I find AI writes code as least as well as I do (with 25yoe). So I'm now mostly reviewing. But I also find it reviews code better for issues than I do. A LOT better than I do. Now, finding "issues" isn't the only reason to review. It's also for understanding. But for "issue finding" my agent can just review it's own code (Or rather, agents review each other's code). It works, and produces acceptable quality code. I don't find there's a buggy and bloated mess left behind any more. It's by no means perfect, but this is like self driving cars: what's being replaced sure wasn't perfect either.

I'm very good at telling agents what to do. That's not a problem. I understand a code base I worked 20 years in like no one else. The problem creeps in slowly: the less I know about this code base, the worse I'll be at directing agents. They'll do ok on their own, and they can certainly help me understand code too in a way my colleagues never could. But still, I'm slowly becoming less and less familiar with my own code base. In a few years, it would be foreign to me. And I would be describing changes in terms of high level features instead of architectural changes, refactorings and so on, that I do now. And I don't yet trust the LLMs to do a good job with that. So right now there's sort of a honeymoon period when the human understanding of code is good, and the LLMs are finally good enough to write and modify code. But I wonder what will happen after that.

The problem isn't its coding or its ability to review code... the problem is its ability to apply the right solutions. AI tends to do really well at high level architecture, but then starts to fall apart when there are 1000 mini decisions needed to implement that architecture. Further more, it will absolutely brute force whatever requirements it's been handed from an "authoritative" source. IOW, it's much more likely to be critical of design decision when they originated from its own context window, than those that are handed down from a ticket, design document, or another agent.
Code is useful because it is an intersection between human and machine legibility.

If anything, LLM coding makes to me the case that we should all move to high legibility paradigms.

If code writing is accelerated, and there's not more assurance that at least someone knows the code because they actually wrote it, we should only ever generate code in very explicit and readable ways.

I'm having a lot of success with this approach. I don't want to encapsulate it in terms that might trigger emotional responses, but there have been texts and tooling available for decades that enable writing code in very specific ways that make the code base extremely readable and reasonable. These techniques were historically considered cumbersome and pedantic exercises in purity (hint) but now we have these metaphorical heavy duty tractors for syntax and semantic work so they suddenly become so much more tenable and arguably the only sane approach to scale up the usage of these power tools of the mind.

loading story #50545959
loading story #50544764
I've found that the way I strike a balance is to:

1: Carefully pick critical areas that I do by hand, and have AI do the other 90%.

2: Make small changes by hand before / after doing the work with AI.

Most important: Slowly rotate the areas that I do by hand. This way, I keep my hands-on knowledge good enough to give AI knowledgeable instructions.

loading story #50548537
loading story #50550110
We should probably take a step back and think about why we ever did code review in the first place. I'd say there were two primary forms: "mentor review" and "peer review".

"Mentor review" describes the situation where there is a knowledge imbalance between the author and reviewer. It can represent an onboarding situation but it isn't static - there are always areas of the codebase that some people are more familiar with than others.

A "peer review" is more the situation where both the author and reviewer have similar knowledge in a given area. The purpose of the review here is primarily to look for oversights.

I'd say, the peer review should be deprecated at this point. AI can generally do a better job at looking for minor / localized problems. The "mentor" type review should stay however as it is still very valuable.

loading story #50548315
loading story #50548910
loading story #50547830
> So right now there's sort of a honeymoon period when the human understanding of code is good, and the LLMs are finally good enough to write and modify code.

This one worries me enormously. What happens when we stop adapting the stuff we know, and everything becomes code we've inherited from someone/something else?

> And I would be describing changes in terms of high level features instead of architectural changes, refactorings and so on, that I do now.

While I haven't worked on any 20yo code base, while working on my projects, I have found that iteratively I am asking to do many of the low-level things like architectural changes and refactorings.

These situations often pop up when I am not getting an expected output, multiple back and forths, specific bugs, continuously flaking tests. I usually then ask it to explain the architecture and what's going on. I add the patterns it's missing or I feel it should consider from next time onwards, to the harness.

It's not the same as pre-llm era but I think this is how things are going to evolve.

loading story #50546430
loading story #50546679
It's really similar to when you add another human programmer. You won't be as familiar with the code they write. I have a junior programmer working for me, and I feel the same way about his code (sometimes AI written) as I do with AI written code
loading story #50548415
A big part of reviewing code to me now is just maintaining my mental model of how the system works and why so I can continue to write good prompts to evolve it. Also checking for various brittle and architecturally unaligned smells; it's more of a skim to stimulate questions for filling gaps in my mental model and to find and fix smells.

I think of clankers as "lossy intention amplification and reprojection devices with hopefully tasteful distortion." Whether they're amplifying and reprojecting our intentions into code or a bunch of assumptions in some specification document, I think the problems are the same: if we stop even skimming the code at some point, it will still need to serve a purpose valuable to humans to be worth anything. It's kind of like getting a device that can answer the ultimate question of life, the universe and everything: you still need to know what questions to ask it.

What models are you using?

I have to beat the GPT and Claude models over the head with a brick every ten seconds for it to even partially code or design as well as me. Despite precise and generous specification, they frequently make horrible architectural decisions.

When I read claims like yours, I want to withhold judgement and understand, because it 100% does not line up with my experience and my gut reaction is to question your own capability to either write, read or understand quality code. I code all day long with AI models but it's an extremely frustrating experience at times. And don't even get me started on all the annoying meta behavior outside of coding, such as Sol's obsession with "tests" or competing for world's busiest-yet-least-functional UI

loading story #50544766
loading story #50544882
loading story #50545284
loading story #50546707
loading story #50544425
Writing the code was never the hard problem, of course it required stuff like reading docs and literal typing it on the keyboard. But designing a robust system that is open for change and has the right abstractions and boundaries is what a software engineer should be mainly concerned about and AI still pretty much sucks at this. Agents can now bloat a codebase 100 times faster and they don't feel any pain while doing it.
loading story #50544083
Fully agree with you. do remember that that's how a lot of "product" people feel
loading story #50544297
loading story #50544570
My personal bet is that in a few years AI will be better than humans at "de-sloppifying" code too.
loading story #50547739
The llm code still sucks, and sadly I know plenty of people with 25yoe whos opinions I wouldn't respect when it comes to programming.

Most of them haven't really wrote that much code in the last 10 yrs because they became more of managers and LLMs blow their boomer minds away.

Opus 5.5/Fable will light your codebase on fire. I really dont understand yall who are that impressed. Not saying its not useful, but it isnt what this site would lead you to believe.

loading story #50550471
loading story #50547213
loading story #50548879