As you may have already noticed, robots are getting increasingly good at building software. Coding is now largely a solved problem, and it is like that since a while.
This is a big change, and, to me, an expected (r)evolution. Since inception, complexity of computers grew, but difficulty of writing programs was shrinking.
In the past, you'd need to talk to machine in plain custom CPU instructions, then in a more general and portable Assembly language, then in higher level languages like C. It was very hard to build a complex software system back then, and it required a lot of knowledge and experience. Few people would want to connect their lives with computers, the bar was really high. Money and business interest were not there because of questionable return on relatively high investment.
Naturally, as the layer of abstraction, new simpler languages emerged, mostly built using C. More people were able to comprehend and enjoy programming as a concept. More complexity in software was unlocked (by hiding it in library code and compilers), making it appealing to companies willing to spend money on automation. More computers at home, with games and tools.
This process accelerated exponentially with Internet and even simpler programming languages like PHP, JavaScript or Python. We seemingly had an unlimited demand in engineers, that were able to build relatively simple software for the expanding Web. We were fine to trade compute for speed and simplicity of development. We've got a lot of bloated mediocre software. What was running okay on 16MB Pentium 166MHz in 1997, now may require 100x more CPU and RAM for no good reason (hello Electron!).
Low-level tricky programming did not disappear, it became a tiny part of very wide landscape. This tiny, but powerful part brought us to the next level - programming in natural language. Computer models learned all the prior programming experience, and got to be able to apply it in a meaningful way!
What does it mean for Software Engineering?
As with many other new things, people have different opinions.
AI Slop
Some are annoyed by AI generated code that does not meet their quality/aesthetic expectations. Excessive, unreliable, repetitive and unstructured. Code that may work in some conditions, and crash at a slight deviation. With poor naming and ugly code style.
This can happen, but this is not invented by AI. I've seen tons of ugly code before: undertested, undocumented, overly optimistic and just disgusting. I'd argue, I've seen more ugly code produced by people, than I've seen from an AI agent.
Regardless of who wrote it, ugly code is often a problem in communication (of one's expectations). When a developer joins a new team, their code may be considered poor because it does not follow local practices and styles. That does not necessarily mean the code is indeed poor, another team and code users might be happy with it. You need to deliver your expectations to avoid "sloppy" code. Reasonable expectations with reasonable design (and I don't mean code with core deficits by it) were the key to reasonable productivity long before AI.
AI can make mistakes, just as we do, it is our responsibility to expose and get them fixed. Proper testing and use case explanation makes it easy (same as in code written by human).
AI slop is less the problem of an agent in my opinion, but instead an indication of poor steering.
Everyone is a Team Lead
With AI you can have multiple simulated developers at your service. It is a great power, and it can deliver code really quickly. If you want this code to be useful and correct, you need to build proper process and methodology.
Same as with real team of engineers. If you want good code that lasts and works reliably - you need to develop it in proper way. Code acceptance protocol is up to you to define.
Recently we've seen projects of impressive complexity implemented by AI agents (such as *Craft or progress on console emulation/decompilation scene). This is a strong evidence, that with proper process current AI agents can achieve impressive results.
Quality Assurance
That includes test coverage on different layers, benchmarks in different conditions, stress tests, backwards compatibility, fuzz tests, fault injections and everything that improves your code stability against an influx of changes. AI agent would be happy to instrument your project with chosen methodology - but it is up to you to ask for that.
I think acceptance protocol is now one of the most important things in software engineering. With increased pace of changes, gating code with strong quality metrics is the only way to improve without regressions. The quality of your test suite and behavior documentation matter more than implementation.
Code Review is a Nightmare!
Back in the day writing code by hand was usually slower than reading, but even back then we had practices to deliver code in smaller chunks to make it easier to review.
Now agents can generate thousands lines of relevant code without breaking a sweat. How do you make sense of it? Unfortunately, it seems human review can't scale enough to cover that.
Reading and understanding code is same magnitude of difficulty as writing code. In order to make a quality review, you basically need to re-implement the change yourself and then reason about the differences in implementations. This is laborious and rarely happened before AI. In practice, teams are often ok to have a surface review: test coverage, reasonable test expectations, reasonable high level changes, CI is green.
Such a code review can easily miss critical issue that's not on the surface, like for example security issue in updated library or performance impact in neighboring component.
On the other hand, agents are capable to re-implement the change and identify challenges along the way just for sake of code review. From my experience, code review driven by an agent is often deeper and more thorough. It better scales to large changes too.
A human reviewer, as a deciding authority, needs to scope review area - most important is to nail design and public API, and make sure expected public behavior is verified.
Don't trust the agent, use another agent to cross-check and explain.
No More Coding
Many people (myself included) find coding fun. Getting to a problem, finding creative and elegant solution idea, iterating through the code and validating result can bring a lot of joy, discovery and satisfaction. Now an agent gets all that, and we only get to press the "next" button, like we're installing an app.
This can be the case, but I'd argue it is up to you to decide how much you want or need to be involved.
I personally prefer to stay deep in the loop of agentic work and discuss changes and decisions at length before approving them. Such an approach shifts my role more into design area: what data structures would we need, how communication between components should happen, which consistency promises should be given, which edge cases to consider, and so on. This area is even more interesting in my opinion, than low-level implementation coding. It gives a lot of joy when you design a solution for a complex problem, and verification step proves it - even if you haven't written a single line of code by hand.
AI agent makes is easy to experiment and try different strategies, learn different languages. As a Go expert, I'm now a happy Rust learner through real high-impact projects with production value.
This feeling of high pace learning through experimentation have re-ignited my coding interests.
Although I'm coding a lot, I've noticed that my pace was slowing down over the years. But since mid-2026, when I got more to work with AI agents, I'm enjoying it quite a bit, so my time spent on building software grows again.
Learning unfamiliar language or unknown domain areas with AI feels great, but it only happens if you have interest for that. If all you want is to finish that annoying Jira ticket and get a beer, AI can make your life easier, but it will not help you to improve.
AI can feed your curiosity only if you have it.
Polyglot Engineers
The boundaries between programming languages are disappearing. Now, given good understanding of what and how needs to be done, you don't need own deep expertise in specific language, you can pick the best for the job and learn from resulting code and behavior.
If you are a specialized Backend Engineer, you can become an ok Frontend Engineer with AI assist, and vice versa.
Rust is one the beneficiaries of this situation. Normally, it is a language with high barrier to entry, but with a great deal of performance and compactness. Many AI assisted projects pick Rust for its solid memory safety together with top notch performance. Another thing that makes Rust such a great language for agents (as opposed to, say, JavaScript or PHP) is training code corpus.
Models infer patterns and solutions from the code available in the world, and turned out high barrier to entry makes most of Rust code reasonable and high quality. Which in turn makes AI generation reasonable and high quality.
AI Will Take Your Job
It is very likely that many jobs will be taken by AI, mine is at risk as well. It is not great, but that's how progress works. Automation is well known to replace human labor and push people into new professions.
Even though risk is real, I'm convinced that people, that can do great things with or without AI assist, will stay in demand. Detailed novel vision is not something that can be generated (at least for now). AI is good a following defined steps, but less so when it comes to genuine creativity. There is hope for us.
Code Enshittification
It is tempting to blame AI if the code is no longer manageable. But AI is just a tool, it can't be at fault or held accountable, an operator can.
Shitty code was plenty in existence long before AI. With same old excuses: tight deadlines, lack of capacity, lack of motivation, lack of vision, poor management, building on the broken design, and so on.
AI just accelerates unhealthy practices in an already unhealthy context. That's unfortunate, because with better steering agentic impact can actually improve and heal abandoned "tech debt".
Everyone Can Code
We're entering an era of software liberation, no proprietary code can sit still just because it is obscure. Many computer problems can be solved with a one-off effort. If you need a service for your own personal project - you can get it much cheaper, than hiring a professional software engineer.
Would those solutions scale and last? Not necessarily. Engineering expertise is still needed for production reliability.
Is production reliability must have? Not necessarily either. For your own one-off problem, where you can run the tool, use the result once, and then forget about it - AI is just great!
I also hope that now, with this level of automation, we're going to debloat and fix all the tech debt and set snappy operation as a standard. From my experience, agentic performance optimization is very efficient.
Top comments (0)