My feed is flooded with Agentic Coding hype, as I’m sure is yours.

After spending the last year using AI agents in software projects, I can't help but notice how similar the narrative feels to the Scrum revolution twenty years ago.

Back then we had Scrum evangelists. Today we have Agentic evangelists. Both promise dramatic improvements in productivity, both are presented as universal solutions, and both seem strangely immune to criticism. Whenever results fall short, we're told the problem isn't the methodology or the tool, it's "you are doing it wrong". Yesterday it was about people not being ready for Agile, today it’s “your harness probably sucks”. Endless loop. Similarities don’t end there.

Agentic Coding is going mainstream, becoming a best practice, and is being adopted everywhere. But I suspect many organizations will eventually find themselves wondering why the outcomes fall short of the promises (many already are).

The underlying assumption behind much of the current hype is that writing code is the hard part, the main challenge and it needs urgent fixing. I'm increasingly convinced this rarely is the case.

We use agentic coding every day and it has become an important part of our engineering toolkit. It helps us move faster, explore solutions more quickly, and automate a significant amount of repetitive work. The productivity gains are real. In many situations (not all). What is not true is that AC is a magic wand that fits every purpose and makes engineers redundant.

The biggest lesson we've learned is that introducing AI into software delivery doesn't remove constraints, it rather moves them. If developers produce more code, it overwhelms other parts of the process. Requirements become more important. Testing becomes more important. Deployment becomes more important. Organizations that accelerate implementation without adapting everything around it often discover that they haven't eliminated bottlenecks, they've relocated them.

Quality is where things become even more tricky.

Current models can generate acceptable code most of the time and occasionally very good code. However, they struggle to do it consistently. They often lack the qualities that emerge from deep domain knowledge, long-term thinking, and engineering judgement. The paradox is that the more code an AI agent produces, the more valuable experienced engineers become.

Add to this the swaying quality of outputs generated by some models and you can quickly find yourself in a mess. We've had days where a workflow that performed reliably suddenly broke down in quality, only to recover later without any obvious reason. Whether that's due to model updates, throttling, context limitations, or something else, the challenge remains: unpredictability is a concern.

We've seen this repeatedly, especially in legacy modernization projects. AI is remarkably good at understanding what existing code does. It is much less reliable at understanding why it does it, which behaviours represent business value, and which are simply years of accumulated mistakes and technical debt. That distinction often determines whether a project succeeds or fails.

Therefore, someone still has to validate the code itself, check assumptions, spot edge cases, challenge requirements, and make architectural trade-offs. As the pace rises, there is often much more human communication needed than initially anticipated. In many cases, it defeats the purpose. Are we still automating processes, or creating new ones, just with more productivity pressure for ourselves?

The fact is that nowadays more software gets built. But that's not inherently a good thing. My best guess is that mid-term we might see more poorly understood requirements, more weak architecture decisions, more technical debt, and more systems that work just well enough to make it into production (or stop just before that) but are not sustainable in the long run. At some point, many of those systems will need to be fixed, stabilized, rewritten, or modernized. We still have a long way to go to trust LLMs to handle all code on a new meta-level that wouldn’t require deep human interaction to work well.

Ironically then, some of the biggest winners in the AI era may not be the people who embraced every new trend without hesitation, but the engineers and companies that kept a cool head, understood both the strengths and limitations of these tools, and took the time to evaluate the depth of the pool before diving in.

I'm optimistic about AI and I believe agentic development is here to stay. But I also think we're currently underestimating the risks of treating these systems as magic wands rather than simply new tools that still require deep human training, judgement and accountability.

We've spent the last year learning this in production. If your organization is trying to adopt AI responsibly rather than simply follow the hype train, we'd be happy to share what worked, and what didn't.

Thank you for the attention to that matter.

MS

AI is changing how software gets built. But it’s not a low-hanging fruit