In 2023 AI in the editor was beefed-up autocomplete. In 2026 agents read the entire repository, run tests, open pull requests and iterate on failures. The jump is real. But after a solid year of daily use in our team, the picture is more nuanced than the enthusiasm you read on LinkedIn.
Where agents genuinely pay off
Well-fenced, repetitive tasks
Mechanical migrations, dependency bumps with breaking changes, generating tests for existing code, CRUD boilerplate that follows a pattern already in the repo. Here the agent does in twenty minutes what took half a day by hand, and does it well because it has an example to imitate.
Exploring unfamiliar codebases
"Where is the final order price computed?" on a project inherited from another vendor. The agent reads, cross-references, answers with files and line numbers. It saves us the worst hours: the ones spent understanding someone else's code.
The first draft of a bug fix
Given a stack trace and a failing test, the agent almost always reaches a correct diagnosis and a plausible patch. Not always right, but a starting point that shortens the loop.
Where they create debt
- Plausible but wrong code: risk number one. A patch that passes tests but introduces a wrong edge case costs more time in review than it saved in writing.
- New features with architectural decisions: here the agent lacks the product context that lives in the team's heads. It produces something that works but isn't what's needed.
- Silent over-engineering: left free, the agent adds abstractions, wrappers, "flexibility" nobody asked for. Code grows, readability drops.
The bottleneck moved
The bottleneck used to be writing the code. Now it's reading and verifying it. An agent can open five PRs in an hour; no human reviews them well in an hour. If review becomes a rubber stamp, debt goes straight into main and you pay for it three sprints later.
The rule we set for ourselves: the agent's speed must never exceed our capacity for serious review. Better two PRs understood well than ten accepted on trust.
How we keep them in check
We give agents written context, project conventions, architectural patterns, what NOT to do, in a file they read every session. We ask for small, verifiable diffs, not rewrites of whole modules. And we keep the human as the author of the decision: the agent proposes, the team signs. It's the same pattern we used for product-side agents in 2025, applied to our own craft.
Verdict
AI agents in 2026 are a serious productivity tool, not a replacement for the developer. Whoever uses them to amplify a strong engineer goes faster. Whoever uses them to replace technical judgment accumulates debt at double speed. The lever isn't "how much code the agent generates", it's "how much code the team can understand and own".