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.
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.
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.
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
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.
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)
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.
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.
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...
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.
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.
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.
> 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.
"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.
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....
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.
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?
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.
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.
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.
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.
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."
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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
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.
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.
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.
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.
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
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.
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.
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
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.
What a horrible thought. Some of us like writing code.
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)
What's up with all the trackers? Sounds interesting but closed immediately due to their presence
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.
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.
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.
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...
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.
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.
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.
> 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.
> 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.
"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.
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....
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.
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?
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.
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.
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.
The same thing was said when CAD and printers replaced manual drawing boards.
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.
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
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.
Cue Rick Rubin “I have no musical talent or ability at all” or whatever he says in that one interview
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
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.
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.
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.
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.
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.
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.
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.
This must be why I keep getting told by people that it's better to offload the reviewing to the agents as well.
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.
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-...
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.
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.
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.
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
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.
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
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.
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."
if you stop writing assembly, you also get worse at manual compilation
OT but the combination of line height and font size on the website makes the article so uncomfortable to read!
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.
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.
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.
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.
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.
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.
A full on Ouroboros