AI Agents Writing Code — Hype or Reality?

The Never-Ending Discussion

On LinkedIn, I see two kinds of posts every day. One type shows a 30-second video of an AI agent building a complete application, with the caption “Developers are cooked.” The other type features lengthy essays about why AI will never replace real software engineering. Both are wrong, and the truth is — as so often — considerably more nuanced.

I have been working with AI coding agents daily for over a year now. Not as an experiment, but as part of my productive workflow. I have used them to build SaaS products, automate infrastructure, and even developed large parts of Atoo Studio itself with AI agent support. I have a pretty good idea of what works and what does not.

What AI Agents Do Well

Scaffolding and Boilerplate

The most obvious use case, and the one that works most reliably. An AI agent can set up a project in minutes that you would previously have spent half a day configuring manually. Project structure, configuration files, build pipeline, base architecture — agents handle all of this reliably and quickly.

I use this every day. When I need a new microservice, I describe the basic structure and let the agent scaffold it. It creates the folder structure, the base configuration, the Docker files, the CI pipeline, and a few basic endpoints. Within ten minutes, I have a running foundation that used to cost me an entire morning.

Writing Tests

Writing tests is a task that many developers do not enjoy. AI agents are surprisingly good at it. You give them a function or class, and they write unit tests that cover edge cases you probably would have overlooked. The tests are not perfect — sometimes they test implementation details rather than behavior — but as a starting point, they are excellent.

Documentation

Another area where AI agents shine. Code documentation, API documentation, README files, comments — they handle all of this quickly and at good quality. They can even analyze existing undocumented code and add documentation retroactively. This is invaluable for legacy projects.

Refactoring and Code Migration

AI agents are very good at restructuring existing code. Splitting a class, simplifying a function, migrating code from one framework to another — they handle such tasks reliably, as long as you give clear instructions. I recently migrated an Express.js API to Hono and had an AI agent do most of the work. The result was clean and worked on the first try.

Bug Fixing for Clear-Cut Errors

When a bug is clearly reproducible and the cause lies in the code — a typo, an incorrect condition, a missing null check — AI agents often find the error faster than I do. They can analyze stack traces, find the relevant code, and suggest a fix. This works especially well when the agent has access to the error message and the relevant code context.

Where AI Agents Hit Their Limits

Complex Architectural Decisions

Should I use microservices or a monolith here? How do I partition my database? What consistency guarantees do I need? An AI agent cannot answer these questions meaningfully because they require deep context: team size, expected load, business requirements, existing infrastructure, budget.

I have seen multiple times how AI agents give the “standard answer” to architecture questions — the solution recommended in most blog posts. But the right architectural decision is almost never the standard answer. It is always context-dependent.

Domain-Specific Logic

When I am building a billing system for the Austrian social security system, I need detailed knowledge about contribution categories, assessment bases, and social security law. An AI agent does not have this knowledge — or worse, it has approximate knowledge and gives confident but wrong answers.

The more specific the domain, the less useful AI agents become. In generic web applications, they are rockstars. In highly specialized professional domains, they are at best an assistant that needs to be guided.

Security-Critical Code

Authentication, authorization, encryption, input validation — these are areas where I treat AI-generated code with particular caution. Not because AI agents inherently write bad security code, but because the consequences of mistakes here are especially high.

I have seen AI agents propose JWT implementations that technically work but contain security vulnerabilities. Or SQL queries that look parameterized but are susceptible to injection in certain edge cases. These errors are subtle and only noticed by someone who understands security.

Long-Term Consistency

AI agents are good with individual features. But with a project that grows over months, things get difficult. The agent has no long-term context. It does not know why a particular decision was made three months ago. It does not see the big picture.

This leads to AI-generated code in large projects sometimes becoming inconsistent. Different naming conventions, varying error-handling strategies, redundant abstractions. All of this can be caught through good review, but it requires attention.

The Gap Between Demo and Production

Most impressive AI coding demos have something in common: they show greenfield projects. A new project from scratch, a single file, an isolated feature. In this context, AI agents are indeed impressive.

Reality looks different. Most professional developers work on existing codebases. They have to deal with legacy code, respect existing architectures, adhere to coding standards, and work with team conventions. In this context, AI agents are less impressive but still useful — if you know how to deploy them effectively.

My Practical Workflow

My workflow has settled into a pattern over recent months that works well.

For new features, I start with a clear description of what I want, including context about the existing architecture. The agent creates a first draft. I review it, give feedback, and the agent iterates. After two to three rounds, I generally have usable code that I then fine-tune.

For bug fixes, I give the agent the stack trace, the relevant code, and a description of the expected behavior. In an estimated 70% of cases, it finds the bug and suggests a correct fix.

For refactoring, I describe what I want to change and why. The agent carries out the refactoring, and I verify that nothing broke.

For architectural decisions, I use AI as a sparring partner, not a decision-maker. I discuss trade-offs, have it show me alternatives, and then form my own opinion.

Conclusion: Neither Hype Nor Disappointment

AI coding agents are a powerful tool that can significantly boost productivity. But they are not a replacement for developer competence. They amplify what is already there: good developers become even more productive with AI agents. Poor developers produce more bad code, faster.

The narrative that “AI replaces developers” is nonsense. The reality is: AI is changing what we do as developers, and how we do it. And that is both less dramatic and more profound than the headlines would have you believe.