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

(cekrem.github.io)

257 points | by theanonymousone 7 hours ago ago

129 comments

  • JamesLeonis 3 hours ago

    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

    • sdeframond 7 minutes ago

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

      To some extent, you can: better doc and better support scripts (linters, tests, infra as code, etc) do not replace a human being but it goes a long way toward improving your coding agent. Especially since many of those ad-hoc scripts wouldn't even have been written by hand in the first place. The cost/benefit ratio changes.

    • DanielHB 3 hours ago

      I found that keeping my prompts small and incremental and reviewing the output at each step helps a lot both with keeping my skills sharp and keeping knowledge of the code. It is interesting that I actually learn new tricks from LLM generated code and keep it in check when it goes overengineering.

      But that makes LLM speedup like 1.5x the manual-typing coding speed, vs 50-100x you can get if you vibe all the way.

      I still use LLMs for troubleshooting, searching, codebase knowledge gathering, solution exploration, writing tests and documentation and whole-codebase changes and there the speedup is dramatic. However I don't feel I become a better developer for doing these kind of tasks without LLMs.

      For documentation and tests though I feel I am slipping on reviewing the output because it is just so boring that I often "surrender" the task to the LLM which generates bloated tests and bloated docs.

      • pezgordo 2 hours ago

        I divide projects in "care code" and "care result". I am buiding random tools all the time for which I dont check the code. For my long term project I do check the code.

        This is the best I came with so far, but I have to admit how slow my main projects move, if at all.

      • JamesLeonis 40 minutes ago

        I think I have the same experience, both good and bad. Smaller tighter feedback loops are like smaller PRs I review but at a much slower overall speed multiplier than straight vibing. Additionally I found I can use smaller context and even sometimes smaller models and get results back faster, but I must be more hands-on guiding things.

      • techmunky 2 hours ago

        There is still value IMO in creating atomic tickets for systems where humans are in the loop. Building a new UI experience? Have each component at minimum be it's own ticket. Maybe theres additional layers where you can break it down, scaffolding, skeletons, etc. For human led teams where AI is just making the code and helping with design decisions I think this is still the way to go for the bulk of the work. Can AI do everything soup to nuts? Sure but nobody is going to review that well and you can't revert part of it without taking out the whole change.

        If you have a robust ticketing solution at your org just use it. Theres probably a baked in MCP. At work I use(d) JIRA (laid off, hmu w bay area or remote work), at home github issues are fine to a point then I use vikunja or openproject depending on the box its gonna live on.

        If I was Junior in 2026 I would be breaking down work into the smallest components possible so that my understanding of the work was scoped and more importantly the inevitable AI sprawl would be similarly scoped (and easier to rein in/call out).

        If you don't know how to break the work down ask for help. I wish I asked for help more earlier in my career.

      • pragma_x 2 hours ago

        I can attest to the first part. I think I've gone on record elsewhere in comments on HN that I much prefer using an LLM in a "sage" mode, where it functions more like a tutor/mentor than between me and the work. This has accelerated learning and, like you, I've learned new tricks this way.

        As for the last part about bloat, I've started tinkering with prompts that attempt to minimize generated code output. I'd wager that having agents take a second or third pass to "prune" the output of the former would work too.

    • bigbadfeline 2 hours ago

      > I agree with the author we're in a weird moment

      We're in the twilight zone, AI ain't there yet, neither are developers.

      > where the Best Practices seemingly flipped

      There will be new BPs when AI becomes real - for now it's enough to make sure open source AI gets there first.

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

      Because of this and a lot more.

    • jmathai 31 minutes ago

      It is a weird state.

      - You can't write code as fast or "good enough" as AI.

      - Not writing code quickly atrophies your ability to do anything code related.

      It seems to me like a giant bet on AI being able to replace software devs (and soon - other professions). And you're forced to participate in that bet if you want to stay a software dev.

    • chrismorgan 2 hours ago

      I love coding and I love teaching. I greatly enjoy working with novices because I can teach them; but I’m not a manager. Agentic stuff sounds like my nightmare: little of the coding, none of the teaching, all of the managing. Ugh.

    • enraged_camel an hour ago

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

      Why not? Over the past 20 years I've worked with some incredibly smart and accomplished engineers, some of whom have single-handedly built complex products and services used by millions. And today none of them would come anywhere close to what frontier models are capable of.

      • discreteevent an hour ago

        When enraged_camel lies through his teeth like this it's not to try to convince anyone who has experience. It's to catch those who don't. This site used to be a place where developers helped each other out and that's still true to some extent. But for a lot of greedy people on here lately, you are no longer an equal. You are the mark.

        • kazinator 25 minutes ago

          It's not a lie in the sense that those individual developers cannot match the KLOC/day output.

      • viklove 44 minutes ago

        It's always a guy saying "I know some really smart dudes, and AI is better than them," and not "I'm a really smart dude, and AI is better than me."

        Curious...

    • Teever 3 hours ago

      I agree with your comment but I also think an important factor to consider is that AI is also capable of producing good quality documentation, diagrams and explanations of the code that it produces.

      This has the potential to mitigate some of the atrophy that is well documented in management positions and perhaps for someone in such a position (be it managing people or AI) to review code better than they otherwise would.

      • JamesLeonis 3 hours ago

        The ideal manager sacrificed their immediate day to day skills to mentor a team in those skills, thus increasing the overall velocity while the manager's individual velocity atrophied. Both AI and outsourced workers are run by companies provide a service for a fee, but refuse to take any responsibility for the output. If their work is delivered broken your only recourse is to resubmit the work and pay them again.

        This means we must be just as skilled as before AND manage these other inputs AND take responsibility for the overall deliverable. No wonder developers are burning out.

      • matltc 3 hours ago

        Yes, but the problem is that you get a firehouse of information that is difficult to manage.

        The recurring problem I see is that we have been given immense power but abdicated responsibility. That is understandable, given the marketing and packaging kf the tools as "agents" that do tasks end to end.

        Reality is that you need like one or more specialists in devops (mlops? I think that's a thing) to implement a reliable pipeline. The parallel agent model has never worked for me, because I am a careful reviewer

        https://www.reddit.com/r/ClaudeCode/comments/1y0yquc/they_pu...

        Apologies for raw reddit link, old.reddit.com dead and I can't recall the thing to use now

    • jasonlotito 3 hours ago

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

      Yes, you're right. Moving away from the code would atrophy your programming skills, sort of, but if you're still involved with the code on a day-to-day basis, then you're not moving away from the code.

      > AI-first folks will tell me I should see my new responsibility as being just such a manager over little agent kiddos running around

      Yeah, I've never heard someone talk about it like that, but I'll assume that you have and just say that whoever you're listening to is nobody that knows what they're talking about. I've never seen anyone describe it like that, and you can safely not listen to them.

      Which means if you're getting your information from people like that, you probably are very much misinformed, because I wouldn't trust anyone who said something like that to properly inform me.

      The important thing to realize is: is somebody moving away from code and moving to non-code things, like a management position, or are they still involving themselves day to day with the code and just working with the code differently? And the disinformation that you've been fed seems to have polluted your way of thinking. I would go back and review where you got this information because, again, it's not a trustworthy source if they're talking about kiddos.

  • jarjoura 44 minutes ago

    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.

    • sqren 34 minutes ago

      Your comment makes it sound like what Anthropic and friends are doing is a marketing scam of little value.

      I agree the long-term effects of AI are seriously worrying, but what these models can produce is truly mind-blowing. I can’t say for certain that “coding is solved”. But I sure as hell can’t say it isn’t.

      It feels like we’re close to a tipping point where generating code matters less than being able to clearly articulate an idea in natural language and knowing how to validate it.

  • bengold14 4 hours ago

    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)

    • cgarvis 4 hours ago

      I agree with your premise but I would argue that your still operating under the model that we are all still working with all the "developers" that we needed before because we need someone to type out the code.

      I like your ArchitechMe approach because it operates at what is left. The Software Engineers still need to "work on the system, not in the system". Before those folks were in the code, but with so much being written now we need better tools like you ArchitechMe to make sure the system is operating like we want it to.

      • bengold14 4 hours ago

        Thanks for taking a look! FWIW I believe that we'll still need engineers and more of them, because we're going to start to build more complicated software, faster.

        The problem right now (and why teams are shrinking) is because people haven't figured out how to collaborate at scale with AI IMO, so they just give up and say it's easier to manage a small team of seniors.

    • matltc 3 hours ago

      What's up with all the trackers? Sounds interesting but closed immediately due to their presence

      • bengold14 2 hours ago

        Apologies for the trackers - it's just vercel & posthog so we can improve the website and app.

        Is this not common practice?

    • esafak 3 hours ago

      I don't agree with your premise, that code is cheap and unimportant. It is cheap, but bugs aren't unless you have a monopoly, and vibe coded software as you describe is invariably buggy.

      • bengold14 2 hours ago

        I'm not saying it is unimportant (it's the basis for everything), but I am saying that agents do a bang up job of writing it at this point, and to get the benefit of agents you need to stop reading the code.

        It's almost has hard to have agents write the code and review every line than it is to write it yourself IMO. So either they write and your review and you get a 10-20% bump, or vibe engineer and get a 200% bump.

        I'm attempting to build a way to avoid looking at code, while still being able to engineer because frankly it's hard to engineer without looking at a shared artifact. Anthropic et al want us to just stop engineering and let agents take over, I think we should be empowering humans to work at the correct level with the agents instead.

    • imtringued 2 hours ago

      I'll be honest about your project. Asking an agent to create the model is the wrong way around.

      It may surprise you but code review is actually something you need to automate with deterministic software.

      For some reason people don't seem to understand what a developer's job is.

      Automating code review sounded asinine two years ago because the cost of managing the automated process exceeded the cost of manual reviews. Aka it was pointless busy work.

      But now that we have potentially adversarial agents, it is kind of essential.

  • euph0ria 3 minutes ago

    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?

  • snailcoder 5 hours ago

    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.

    • MSFT_Edging 4 hours ago

      Some things are simply about repetition to fully understand.

      For example, I've been around make files for over a decade, I can read them fairly fluently, but if you asked me to write one from scratch, I would be chained to the docs.

      Another example, I can read Spanish to the level of understanding the gist, but I'll lock up if I need to speak more than a sentence or two.

      With the agents, you can have it generate it, and you'll understand it on a cursory glance, but you won't actually know it. IMO the difference between knowing something, and understanding is whether you can bring it into existence with minimal outside reference.

      With LLMs you feel like you're learning a lot, but you lose out on the hard part that actually commits it to memory.

      To be fair, on the flip side I've written enough basic xxd style debug print functions that I know I don't want to do it again.

      • esafak 3 hours ago

        Who gives a damn if you know the syntax of a Makefile. This is exactly the type of non-skill that should be automated away. All you need to know is what its capabilities are, and when to use it.

        • MSFT_Edging 3 hours ago

          I do because I often need to fix things in locations without any internet connection.

          To fix and debug things, you need a better understanding than you do to introduce the bugs in the first place.

          • dnlgrmm 36 minutes ago

            Well in that case you would have an offline copy of the docs before, and now you have a local LLM which includes that in its weights- but better yet, have both (luckily we still have manpages).

    • beej71 29 minutes ago

      > What about the code you were never able to write because you were time constrained?

      I was still never able to write it, even after I had Claude create it.

    • keybored 4 hours ago

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

      I was hoping that, for every “write X for the Nth” time we would get better tools to obviate that need, only needing to do it one time. The reality is a million times more disappointing.

    • Skinney 4 hours ago

      > What about the code you were never able to write because you were time constrained?

      This makes no sense to me. If something needs doing, it takes the time it needs to.

      > because I’m not spending my time wiring a react front end to a backend for a simple table crud operation

      This also makes no sense to me. Either this crud aint simple, or you’ve invested nothing in automating it.

      • sdenton4 4 hours ago

        "This makes no sense to me. If something needs doing, it takes the time it needs to."

        Triage comes from war hospitals, where the number of people would and needing treatment would often outnumber the staff. Those people need treatment, but the staff didn't have time to attend to them, and so many died.

        Adding technologies often reduces the time or takes to do a thing, allowing you to do more things overall. For example, if you seal a wound with super glue instead of stitches you save time, and more people as a result. (And yes, that was the original use case for super glue!)

        AI assistance is letting us find and fix bugs that we previously didn't have time to discover or to fix. And a million other things that were previously outside our time budget.

  • bemtevi 5 hours ago

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

    • deltarholamda 5 hours ago

      People now may be able to understand it. I'm very concerned about the future programmers who are 10, 15 years old now. If you have never built by hand, how are you going to understand the code emitted from an LLM, or whatever New Thing we come up with in 10 years?

      Back in the 90s, places that hired 3D modelers/animators would say something like "Look, we don't care if you know the program. We can teach you that. What we want to know is can you draw?" There's a base level understanding required for any higher-level endeavor. I would not expect a person who might even be considered an expert Python programmer to immediately be ready to become a core maintainer for the kernel. If you don't do the low-level stuff, early and often, you won't recognize the foot-gun when you see it.

      Maybe the LLMs will get so good that isn't a problem? Okay, sure, possibly. If it gets to that point before all the greybeards retire or die, then it's possible we can dodge what I see is a negative feedback loop. If not, then I think the future is much less rosy.

      • tl 4 hours ago

        In the 90s, we had a sane split between people who coded the tools those animators used in C++ and everyone who got leverage out of BASIC or SQL or Excel. These two groups self-sorted by passion or access to a full computer science education. A majority of software writers have been building mediocre line-of-business software for decades leveraging a poor understanding of code.

        LLMs emitting code are a great workaround for "bury the complexity, I just need the result" and terrible for "this codebase produces long-term value". People are slow to learn the difference, and the AI gold rush profits from the confusion. We thought television would bring Shakespeare to the masses. It didn't, but theater was still there for Patrick Stewart (RIP). Software engineering will be okay.

        • dam_jackalopes 2 hours ago

          I'm still in two minds about this. I'm firmly in the "leverage it" group because I'm here to do my job, make the org money and go home. Agentic coding is great for this though it will likely thin the herd, so to speak, at least in the short term.

          I'm not at all convinced that LLMs will kill software engineering but I'm equally unconvinced that it will be an overall positive for innovation in the field, at least while we're basically all running things through the same handful of closed model orgs. It's just a really weird time where I can't decide if I'd rather jump back and work in the world of five years ago or take my chances and jump forward the same period.

      • popkkksidhd 4 hours ago

        Even with developing, I’ve noticed understanding “beneath” where you’re working greatly accelerates LLM assisted and non LLM assisted work. I think that’s the true way to get good at using LLMs - any other “prompt engineering” kinda stuff is snake oil.

        And yeah, I’m not sure how that goes away either - life is full of tradeoffs, how do you RL things with no objective truth?

        • FeteCommuniste 4 hours ago

          The paradox of LLM usage: the best way to use an LLM well in a domain is to know the domain, but if you spend all your time using LLMs, your domain knowledge may atrophy.

          • lukeschlather 2 hours ago

            The thing is you pick up different domain knowledge. I was using AI to experiment with computer vision stuff last week, and I learned so much about hardware sensors, about accelerometers, magnetometers. I learned about the relationships between pixels and millimeters when you're talking about cameras in some reference frame. I learned about how the speed of light relates to the time it takes for wifi and bluetooth to send a message through household objects. I learned about how sound reflects in spaces and how different frequencies are picked up by microphones in different kinds of hardware I have.

            There's so much to learn in the world. The domain knowledge I used to carry about software, I hope I forget most of it. I hope I learn things that let me do things I never could've conceived of before.

            • FeteCommuniste 2 hours ago

              The knowledge you gain by reading someone else's solutions is real but not as sticky as what you pick up by working out a solution yourself. I fear we are well on our way to the second type being a thing of the past.

              • lukeschlather 2 hours ago

                I wasn't just "reading solutions" I was wandering around my house with different devices, repositioning them, taking video, thinking about how to figure out what was going on. The code is never the point, it's the means to an end, the problems I'm trying to solve, the code is only one piece among many.

        • deltarholamda 4 hours ago

          Understanding "beneath" is a good idea. I used the free version of Grok to generate some Ansible scripts. I don't use Ansible often enough to be really adept, and I appreciated some help.

          It was pretty good, understood what I wanted to do, and broke it up in playbooks/roles/etc. quite well. But then it did things like continuously overwrite the LetsEncrypt cert for each domain with the next one in a loop. It understood "this needs to be a loop" and how to optimize that loop, but not that it was going to overwrite each domain's key with the next.

          I'm a pretty good sysadmin, so I recognized this and could take what it did and fix it, but it required a deeper understanding of the underside of nginx/LetsEncrypt and the filesystem to even see what it was doing.

          Of course, once you run the playbook, test a domain and see its SSL cert is all jacked up you'll go looking for WTF happened, but just blindly taking the output as given meant it was horribly broken.

          It may be that Ansible, by its nature, is a bit sui generis because it touches so many unconnected domains, and therefore is harder than outputting Python. I don't know. But one needs more than a surface level understanding of those domains if you want to catch the LLM being stupid.

      • bluGill 4 hours ago

        The same thing was said when CAD and printers replaced manual drawing boards.

        • bemtevi 3 hours ago

          This is nothing like that situation.

  • fusslo 3 hours ago

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

    • bluefirebrand 3 hours ago

      > The actual nuts-and-bolts of how the code is written is mostly unimportant

      I am struggling to come to terms with this personally. I was someone who really tried hard to make sure the nuts and bolts was good quality. Kept on top of language features, made sure not to use deprecated APIs that could expose security problems, etc

      It wasn't just "to make the code more maintainable" or anything, those choices mattered, or felt like they did

      Now it feels like everyone is saying "those choices don't matter, and never did"

      Have I just been wasting my time and focusing on the wrong stuff for my whole career?

      • dust-jacket 3 hours ago

        No they absolute did matter. They just matter a lot less now.

        I'm going to ignore the using an actually broken API, and instead think about using a sub-optimal one.

        Before, you tried hard to get it right first time, because it was a pain to change if it wasn't.

        Now, that change is much, much easier. A task like "rip out this deprecated package and replace with a new one" used to be a LOT of effort but, if we're honest, not an awful lot of skill. Now its quick and easy.

        Making the right product choices, or architectural decisions remains just as important, because they're still an absolute nightmare to change later, but the nuts and bolts much less so.

        • fusslo 2 hours ago

          right. Making the right choices is really hard

          One thing I am still seeing is we STILL can't admit when we're wrong. We refuse to believe that we cannot think of everything before the code gets into production.

          Really it's some core teams who do not have a 'sustaining' budget. They call themselves Services R&D.

          For example they made a messaging stack with encryption, serialization, addressing, routing, etc. But it has a huge flaw in that there is a maximum packet size. The design is such that an app cannot implement chunking on top of the messaging. So there is no way to transmit data greater than the packet size or do any kind of data streaming. THere are 3 products now who are mandated to use this messaging stack but can't fit into the packets

          It seems like a culture of 'deliver and move on' rather than 'deliver, support, improve'. Not sure how to fix this problem

      • ostensible 3 hours ago

        > I am struggling to come to terms with this personally. I was someone who really tried hard to make sure the nuts and bolts was good quality.

        Think of assembler vs compilers for higher abstraction level languages. When you write in C or Python you trust the compiler to do the right thing and don't routinely review generated assembly let alone machine code.

        It's the same here. You write your program in natural language and have the compiler (ai) make it happen. This is what it will converge eventually to.

    • insane_dreamer 3 hours ago

      > We spend LOTS of time on the design, verification, testing.

      sure, this is short-term because you still have people around who wrote (most of) the code and understand it

      once you no longer have a good understanding of the codebase, you also don't know what to test and validate

      AI is great at writing tons of tests; whether they're the _right_ tests is another question

  • brokegrammer 2 hours ago

    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.

    • Kuyawa 2 hours ago

      This is exactly the approach to take, big corps are full of methods and manuals and useless PMs that won't let go easily. Those who run lean startups will eat their lunch

    • hitcv 2 hours ago

      its already a waste of time. AI is better at reviewing code than 99% of developers, just like its better at writing it than 99% of developers.

      people are still just coping.

  • cgarvis 4 hours ago

    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.

  • abalex 42 minutes ago

    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.

  • gwbas1c 3 hours ago

    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.

  • Overdrivr 2 hours ago

    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.

  • bluGill 5 hours ago

    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.

    • paulryanrogers 4 hours ago

      I wouldn't say reviewing is _very_ different. Someone who can review well can almost certainly imagine and type up similar caliber solutions.

      Someone who can imagine and type up good solutions, can review the work of others.

      IME good reviewers may be a bit better about being gracious with minor differences in opinion/style and managing emotions and politics of everyone involved.

      • christophilus 4 hours ago

        No, I think it is different. My eyes glaze over and my brain turns off when I read code. I find it really effortful, unless I'm particularly interested in it (e.g. reading an interesting paper or Code Complete, whatever). When I write code, I'm in the flow, and it's almost effortless.

        • techdmn 4 hours ago

          Writing code has always been easier than reading and understanding code (for the majority of people). A common failure case in the old days was an engineer who would go around rewriting things all the time, because they couldn't read and understand the code the team had already built.

        • springtimesun 4 hours ago

          It’s definitely different. This was my experience as well. I had to make myself sit down and learn how to review almost the same way I learned to write code in the first place. All the little things I found about coding were there just in different places. Best time of the day to do my most focused work, how to order tasks so I could rest in between will still moving things forward, tools (they are different and like your coding editor setup they benefit from customization), git (I thought I was ok before but it’s a different set of commands I reach for now), the list goes on.

          Being a good reviewer takes reps and practice just like writing.

          The thing I really miss is the flow state. That is elusive for me so far. I can’t even listen to my coding music. I need silence.

  • gosen 5 hours ago

    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

    • handplane 23 minutes ago

      It's like layers of an onion. Coding is the middle, but there's SO much that goes on around it. Some of these inner layers are getting increasingly solved by AI, but nobody wants the inner layers by themselves, they want the full onion, and more skilled developers will still produce better onions.

      There are a lot of skills that are no longer important to software engineering like the specific lines of code that you write, but building software that is maintainable and delivers value to its users involve many many more skills than LLMs can deliver right now.

      If you want to stay relevant in the field, there is no way forward other than embracing the torrent of LLM tools, news, releases, and figuring out how to shape that into your process in a reliable and responsible way.

    • duskdozer 4 hours ago

      It's not really "writing code", and this usage gives it the connotation of "transcribing code". Yes, the things you mention are part of it, but they are still in the realm of plans and not reality.

  • pianopatrick 3 hours ago

    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.

    • hitcv an hour ago

      AI is just a baby at this point and its already better at reading, writing, and reviewing code than 99% of developers. People are just coping and are unwilling to accept this reality.

      Human programming is basically a zombie roaming the streets completely unaware that its dead.

    • doyouevensunbro 3 hours ago

      What a horrible thought. Some of us like writing code.

      • pmg101 2 hours ago

        Literally typing out the characters? Or with auto complete or copilot? I'm fascinated. Personally I usually found it frustrating to work at such a low level to bring a design to life.

        • beej71 20 minutes ago

          I don't actually care about the typing. But I like the problem-solving that goes along with the coding. Just asking the LLM to solve it is kinda boring. I don't have the computer solve my sudoku puzzles, either, and it's most definitely capable of doing that better than me.

        • dam_jackalopes 2 hours ago

          There's a middle ground that goes beyond auto complete. I spend a lot of time in DBs and by the time I corral the agent via prompt to not give me some gross output on a basic bit of SQL, I could just have written the thing myself. Not everything should be a CTE, ya know? This has improved massively on the model's in the last year and will almost surely continue in that direction though. I doubt I'll be keying more than 10% of my code by the end of 2027 and that's mostly down to personal preference and how you build your own mental model of whatever project you're working on. And how hard your PM's and management are whipping you I guess.

      • gottagocode 3 hours ago

        writing code by hand, outisde of hobby work is done unfortunately.

      • pianopatrick 3 hours ago

        No one's going to stop you. Some people still grow food in their gardens even though we have tractors.

  • Kuyawa 2 hours ago

    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

  • sceptic123 4 hours ago

    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.

    • jaggederest 3 hours ago

      To take it in a different direction, Arrigo Sacchi (one of the more legendary managers of AC Milan), who had no professional sporting background, when questioned about his qualifications said "I never realised that in order to become a jockey you have to have been a horse first."

      https://en.wikipedia.org/wiki/Arrigo_Sacchi

      • sceptic123 3 hours ago

        The analogy with football players/managers was in my head too — there are many average professional footballers that go on to become fantastic managers and there are lots of exceptionally talented footballers that make terrible managers.

      • Herring 3 hours ago

        It would probably help a lot, given how badly animals are treated. But yeah his point is right, it's not a strict necessity for the job.

    • Benjammer 4 hours ago

      Cue Rick Rubin “I have no musical talent or ability at all” or whatever he says in that one interview

  • boramdd 6 hours ago

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

  • K3UL 3 hours ago

    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

    • whateveracct 3 hours ago

      i've done the same! i don't give any of my manual coding to my employer anymore

      instead, i give them worse code i get for free (uhh well they pay the thousands of dollars for the tokens)

      so i get to work less and build more stuff i actually own

  • frenchsalmon 3 hours ago

    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.

  • jjak82 3 hours ago

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

  • thatxliner 3 hours ago

    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.

  • nsxwolf 18 minutes ago

    Haven't we begun to stop reviewing it too?

  • hmokiguess 3 hours ago

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

  • jghn 6 hours ago

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

    • popkkksidhd 5 hours ago

      I do wonder about this. I’ve landed on:

      1. Anything that’s boring to write - aka I’m not learning, done it before, I can quickly review - I offload to agents. And still review entirely since it’s my reputation behind it, but I’ve found it to be relatively pain free to review.

      2. Anything that I don’t know what it’s gonna look like, I do my normal planning but with a lot of agent review involved up front. At the end of this, I more or less know the code that’s gonna be written and thus don’t type it myself. I still do line by line review and spend a lot of time on things I don’t understand. It still feels like the same process (wrt understanding) when I had typed and then reviewed what I typed.

      I still (from what I can tell) have the same mental model I did when I hand typed the code, even though for the most part I’m not. I am worried if I’m losing something, but so far it seems ok. It’s also certainly not a 10x speedup.

      • yusefnapora 5 hours ago

        You're pretty much at the top of the "vibe bobsled" [1]. Unfortunately, your lack of 10x speedup will stand in contrast to those who have descended further down the slope.

        Unless you have uncommonly clear-headed management, you will likely feel pressured to increase your speed, since it's so much easier to judge output volume and delivery speed than the ephemeral "quality" that you add by thorough review and understanding. Having already adopted the tooling, and especially having seen it successfully churn out the boring parts, it will become easier and easier to justify offloading the review of those parts. Then a few weeks later, some of the trickier parts become boring, and you rinse and repeat until your only remaining job function is to take the blame when the code nobody has read blows up.

        Not saying this is inevitable, just incredibly common. So even if you are personally able to hold the line, you should expect to be increasingly surrounded by colleagues who have gone all in.

        1: https://dustycloud.org/blog/faulty-towers-vibe-sickness-and-...

      • jghn 4 hours ago

        This is close to what I do. On the back half I will iterate through all the generated code other to ensure I agree with the choices, the "why" behind it all, and will often ask for or even just manually do updates and changes. The AI has done all the heavy lifting, but other than purely personal code I don't really care about everything has been vetted just as much as if I'd written it myself.

      • boromisp 4 hours ago

        On the one hand I prefer to use software developed by people using your process. I don't trust other people's agents and prompts.

        On the other hand, infinite backlogs, crazy tech debt and understaffed dev teams mean a lot of the times off loading more work to agents with less human review will lead to better results on average.

    • bengold14 4 hours ago

      they say you should now "build the factory" - I couldn't disagree more, and I think anyone who works on complex tech with live users knows that you can't just build a factory with code as a product.

  • charlieyu1 2 hours ago

    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.

  • dust-jacket 3 hours ago

    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.

    • ctkhn 3 hours ago

      Composing and playing are totally different. The better comparison is stopping composing because they've got good enough, not stopping playing the instruments they compose for.

      • dust-jacket 3 hours ago

        Yeah.. that's sort of my point though.

        They're collapsing the role ("software engineering") and an action ("writing code") into the same thing. Some roles do lend themselves to this (guitar player!). some do not.

    • mariusor 3 hours ago

      Yes, but a composer that forgets what fingerings are possible for a guitar player with human hands might introduce a fingering that can't be played by them.

  • fph 2 hours ago

    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.

  • edg5000 4 hours ago

    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 4 hours ago

    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.

    • jwilliams 2 hours ago

      I made the same comparison in February (https://jonathannen.com/skilled-humans-in-the-loop/).

      There are a few problems though. The biggest is there simply won’t be a mandate. Flying is a really regulated industry and (compared to software) has a defined set of parameters - at least from a training point of view. Translating that into software would be difficult.

  • rsyring 2 hours ago

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

  • seki285 2 hours ago

    What are the implications surrounding Linus Torvalds and other folks

  • prxtl 4 hours ago

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

  • IncreasePosts 3 hours ago

    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?

    • g-b-r 3 hours ago

      Was there someone writing and reading code, below them?

      • IncreasePosts 2 hours ago

        I'm not sure but that sounds like an HR violation

  • danieldrehmer 3 hours ago

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

  • RomanPushkin an hour ago

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

  • vcryan 2 hours ago

    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.

  • bitwize 3 hours ago

    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 4 hours ago

    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.

    • bluGill 4 hours ago

      You always need review. Otherwise you will not realize you are making something too complex since the lack of complexity will burn you so often.

  • insane_dreamer 3 hours ago

    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

    • ctkhn 3 hours ago

      That has already happened to a crazy degree with regular corporate managers at major American companies software and tech departments, unfortunately. It feels like there is nothing left to cut out but they might just find a way

  • jqpabc123 6 hours ago

    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.

    • Fluorescence 5 hours ago

      It doesn't even need "elimination". There will be negative biasing from their user base, the profitable use cases and the company incentives.

      Those designing for human comprehension, simplicity and maintainability are less likely to be the ones dumping their code-base into a model. When actively hostile to AI, they will be less likely to even open-source their projects. Maybe there is a future for restricted openness with circles of trusted human collaborators.

      However, the users with piles of faulty dog-shit they don't understand or care to even try, will be the whales. The perfect customers, utterly dependent and burning tokens every day for trivia.

      How long until the companies intentionally farm such dependency e.g. gently obfuscating code output? There is a dystopic future for regulated full lock-in where only binaries are sent to the client not code, model-hopping is blocked with legally mandated decompilation guardrails and secure-compute hardware that refuses to run open models.

      • Applejinx 4 hours ago

        From what I've seen being adjacent to some of these folks as they try to parse what Claude etc. say about the code being AIed, this is already happening, and I wouldn't call it gently. There's a whole AI 'get really arcane and highfalutin' language of talking about its own code and I've occasionally called it gaslighting. I got a bit of pushback on the grounds that there is nobody actually there to gaslight you, but all the same I don't think this is subtle.

    • rootnod3 6 hours ago

      A full on Ouroboros

  • wellpast 3 hours ago

    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.

  • augment_me 3 hours ago

    Random assumption made here that carries the whole post:

    > But if we can at least agree that the code that runs our software is a non-trivial part of...

    This is just extrapolation from someone in a specific domain. For a majority of tasks, this is secondary. Output is primary. It doesn't matter how the code looks like, or how it runs, or what bugs there are. If people use the product and it provides some sort of value, that is enough.

    • geraneum 2 hours ago

      > Output is primary. It doesn't matter how the code looks like, or how it runs, or what bugs there are.

      Do you get how the primary is connected to what you assume to not matter?