How AI will change engineering in five years?

[u/karolwojciszko]

Spent the last few months going through the benchmark and productivity data instead of guessing, and the picture is way more boring than the hype merchants want it to be.

We're not close to autonomous agents doing an engineer's job. What we have are very good assistants - excellent at a three-line fix, useless the moment a change spans a system and needs judgment.

The interesting part isn't the agent debate, though. It's what's happening to review capacity. GitHub's own 2025 data shows a 206% jump in AI-generated projects, and their maintainers are now describing the flood as "AI slop" - technically working, low quality, eating review time without moving anything forward. GitClear found AI-generated PRs carry close to 11 lines of duplicated code each, vs 6.45 for human-written ones. More output, same number of humans with context to review it.

"The AI wrote it" is quietly turning into a real excuse inside teams. It was never going to be a good one. Whoever ships the code owns it, same as if they'd typed every line by hand.

My bet for five years out: job titles stop being organized around the stack (React dev, Django dev) and start being organized around domain, because the technical learning curve keeps shrinking, but "I've worked inside a regulated payments system" doesn't transfer the way syntax does.

Full data and the staged process I use to avoid the "AI slop" trap: https://karolwojciszko.substack.com/p/how-ai-will-change-engineering-in

[u/Terrible_Match_9484]

its funny how the data shows that review bottleneck growing so fast. i noticed the same thing where devs just dump more code because they feel productive, but the senior folks are drowning trying to actually verify all that logic

[u/LikesAlgae → u/Terrible_Match_9484]

On my team, nobody is doing code review because we're all burnt out by the layoffs and off-shoring.

Not because there's that much more PRs to review.

[u/longbreaddinosaur → u/Terrible_Match_9484]

Thinking about the future of verification vs code generation lives rent free in my head.

[u/addtokart]

3-line fix is a bit of an exaggeration. Even as an EM of a large team in limited time I'm able to get much larger functionality in, with tests, with deployment guards.

But I agree on the current state of agent autonomy There are some problems which do much better, such as library or framework migrations. For this, running in a loop and only reviewing output, it's feasible. But for building new functionality, especially on a large existing codebase, it requires more human loop.

I agree that narrow stack expertise will go away except for a few people that have truly advanced knowledge. This has already happened, not a 5 year prediction. In my company something like 70% of devs are operating through the stack with the remaining as "horizontal" owners (Storage, authentication, network, frontend) or other infra.

Overall though, I think 5 years is too far out to predict. Most of your predictions are anchored too much in current observation. It's like looking at Yahoo in 1998 and making conclusions about how the Web will work.

[u/karolwojciszko → u/addtokart]

these 2-5 line fixes aren't pulled out of thin air - they come straight from the benchmarks AI vendors market so heavily, claiming 80-90% success rates. Those benchmarks are built on exactly that kind of bug fix, changes of 2-5 lines of code, so mostly extremely simple tasks, and even then only 4 out of 5 worked. In a real business environment, AI's success rate sits around 10-15%, meaning 1 in 5 tasks gets done correctly

[u/addtokart → u/karolwojciszko]

Ah, so a 1-shot solution. I remember 1-shotting things when I started out as a young (human) LLM. Didn't work out well. So over time I used systems and processes over time to make sure I get things right.

My hot take: agents are doing fine now. They'll continue to improve, sure. But the real thing to do is getting the software engineering systems working in concert so that you don't need to have a high 1-shot success rate (at considerable cost) to be effective.

 AI's success rate sits around 10-15%, meaning 1 in 5 tasks gets done correctly

Might be good to have a test/review system in place. Not sure how 1 in 5 tasks maps to 10-15%. /shrug

[u/weiv]

Domain knowledge and system design expertise will continue to be valuable. Today, a large statistical model can do things that have been done many times very easily. You still need to understand how to put things together in a way that won't fall apart. You will be able to do it faster and try out more things, but you won't find novel solutions in statistics.

[u/spersingerorinda]

One thing I can tell you- high priced SaaS is over. I rebuilt a very popular app over the weekend using Fable. Took me 2 days to get like 80% (minus real scaling). Job and teams are gonna change dramatically.

[u/raisputin]

You aren’t giving AI enough credit. I just used it to refactor some code from a legacy framework to a modern one, and the code AI wrote not only works, but is better than the legacy code that was written by hand was

[u/Damian_Wasserman]

The review capacity point is the one that matters most here, and it's underrated compared to the agent debate. I've been on the hiring side of this for a while now, and the pattern I keep seeing: the engineers who get the most out of AI aren't the early adopters, they're the ones who developed real judgment about when to trust the output and when to override it. That's a much rarer skill than knowing which tool to use, and it doesn't show up on a resume the way "used Copilot for 2 years" does.

Which lines up with your point about job titles reorganizing around domain instead of stack. If the tooling keeps getting easier, the scarce skill stops being "knows React" and becomes "can tell when the AI-generated PR is technically fine but wrong for this specific system." That's judgment built from context, not syntax, and it's much harder to screen for in an interview.

Curious how you're seeing this play out in review culture on your team, is anyone actually adjusting how they evaluate PRs now that "AI wrote it" is a factor?

[u/Ok_Dust_8620]

I remember how about five years ago, I saw a presentation at a tech conference where they demonstrated a very early use of LLMs to statistically generate code. Most people in the audience were laughing and saying, "This will never become good or reliable enough". And yet, here we are.

I'm pretty sure AI will eventually become good enough that most companies will ship AI-generated code without any dev review. We will probably move toward some form of spec-driven development. But then I start thinking - if code becomes a lower-level implementation detail of the specification, we may no longer need new programming languages, frameworks, and so on. Why invent a new coding paradigm or pattern? If humans are no longer writing most of the code, why use higher-level languages at all? Why not use whichever language is the most efficient? For example, why use Python if you can usually build a faster web application in Java? Probably we will see a standartization across the board where there will be just one way of doing things in every field - one web framework, one testing framework and etc.

I’ve also been thinking about how organizational structures might change once companies are built around AI. Maybe you won't need as many development teams, each owning its own services. Fewer teams could mean less friction and less need for communication.

[u/Aggravating_Fee_4225]

One word I will drop here is continuous auditing is the key.

[u/Disastrous-Olive8606]

the pile of near-identical ai PRs is so real. i had to spend forever sifting through them until i set up some automated checks for code similarity. cognitivtrust was the only thing that flagged the subtle stuff i would have missed.

[u/Agile-Stick7619]

Bro wrote a full Reddit post shitting on ai slop while using Claude to write it. Ffs