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.
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.
This is the best I came with so far, but I have to admit how slow my main projects move, if at all.
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.
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.
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.
- 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.
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.
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.
Curious...
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.
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.
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
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.
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 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.
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.
Is this not common practice?
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.
What are we bumping 200% exactly, the PR rate? What about the bug rate, and volume?
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.
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.
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.
Just as we don't care too much about how AI does the little things, one has to make space for human engineers to be different from each other and from oneself. I felt I wasn't delivering much value by asking "did you use a list comprehension" or even the spotting of small mistakes. The value I needed to bring was a level up - whether the change hangs together logically with the rest of the codebase and whether the tests really test that and how will this fit the requirement or complicate the future.
As a non coding manager I could still program but I really didn't understand the technical problems my team was facing in the codebase until I got in there and learned it by doing work. It was very difficult to do this while doing the management side of things that eat up time - like hiring people or trying to extract the actual requirements from the wider business but in the end I was able to shelve some of that and get back to code which turned out to be essential.
When I understood the technical problems I could plan and make reasonable team lead type decisions. I could also give my management better information too which they obviously didn't like because it was about things like "that's logically nonsensical and therefore technically impossible."
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.
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.
To fix and debug things, you need a better understanding than you do to introduce the bugs in the first place.
I was still never able to write it, even after I had Claude create it.
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.
> 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.
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.
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....
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.
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'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.
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?
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.
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.
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...
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
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?
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.
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
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.
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.
There really isn't. There may be more to shipping products than writing code, but in organisations of any size that's been specialized into different, other, roles for decades.
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.
people are still just coping.
Reviewing code and writing code a different skills. They are related, but they are very different.
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.
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.
Interesting that reading code seemingly doesn't have the same effect on writing it, according to this author at least.
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
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.
There is nothing else to learn, nothing else to appreciate, and nothing else to review
"The pen is a virgin; the printing press is a whore."
But then people forget you can still "get rusty" from not playing chess in a while.
Human programming is basically a zombie roaming the streets completely unaware that its dead.
I have 30 years professional experience, and 40 years total experience in software engineering. I started with assembler, then to C, then moved on to work in almost every popular language there is.
Last year I started working with AI. I've now gotten to the point where I can build huge, complex systems that would have been an impossibility for a single person before (short of investing decades into it). It's truly an amazing lever.
And then I did a live coding interview today. You know the drill: pick a language, talk about some problem that involves some kind of vaguely tricky algorithm you need to figure out, then code it.
Well, coming up with the algorithm, discussing the tradeoffs in time and space complexity was no problem, but then when I went to code it, I felt a very familiar feeling.
I still remember back in the day when I had to go back to assembler for something after coding in C for a couple of years. It was PAINFUL. It was SLOW. It felt so utterly MORONIC to even be writing an app entirely in assembly in that day and age of compilers that did a pretty damn good job without the slow, torturous pain of tracking registers, PC-relative addressing, stack pointers and all that junk.
Today was a mirror of that. The first thing going through my head is "Why the fuck should I be fighting over the proper syntax to write a fucking loop?" "Why should I have to remember all these damn Python footguns?" "Why should I be trying to remember if it's var x or <type> x or x: <type> or x := something or any of the crazy ways I've written it over the years depending on the language??"
My velocity was so slow it felt like I was walking in molasses. My thought flow was jagged and irregular as I fought for every line of code, trying to decompose the algorithm in my mind into primitive steps, just like it felt when I went from C to assembly that day. It just makes no sense to write code this way!
I probably won't get the job, but I also realized that I probably don't want a job that doesn't embrace AI assisted software development the way I do. I don't think I could handle working that slow again, even if the pay is great.
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.
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
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
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.
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-...
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.
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-...
There is a difference between building a thing, maintaining a thing, and understanding a thing. You don't have to do any of the one to be able to do the other.
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.
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.
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.
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.
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).
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.
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 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.
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.
there won't be anyone with technical knowledge to manage the agents; it'll truly be a black box
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.
> 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.
Do you get how the primary is connected to what you assume to not matter?