15 comments

  • sceptic123 1 minute 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.

  • bengold14 32 minutes 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 16 minutes 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 10 minutes 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.

  • snailcoder 1 hour 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 23 minutes 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.

    • keybored 36 minutes 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 47 minutes 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 34 minutes 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.

  • cgarvis 11 minutes 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.

  • bemtevi 1 hour 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 1 hour 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.

      • bluGill 2 minutes ago
        The same thing was said when CAD and printers replaced manual drawing boards.
      • tl 18 minutes 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.

      • popkkksidhd 51 minutes 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 0 minutes 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.
        • deltarholamda 25 minutes 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.

  • prxtl 5 minutes ago
    [delayed]
  • bluGill 1 hour 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 38 minutes 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 27 minutes 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.
        • springtimesun 11 minutes 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.

        • techdmn 6 minutes 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.
  • edg5000 18 minutes 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 16 minutes 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.

  • jghn 2 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 1 hour 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 1 hour 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 45 minutes 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 41 minutes 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 30 minutes 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.
  • gosen 1 hour 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

    • duskdozer 19 minutes 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.
  • boramdd 2 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."

  • j45 13 minutes 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 0 minutes 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.
  • jqpabc123 2 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 1 hour 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 27 minutes 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 1 hour ago
      A full on Ouroboros
  • arbor-group 50 minutes ago
    [flagged]