After months of hype, I finally used an AI agent on a real project, and one thing genuinely impressed me, to the point of seeing immense potential for engineering teams. What struck me wasn’t the model’s raw ability to generate code, but its disarming ease at adopting the conventions already in place. An AI agent aligns extremely easily with the rails an organization has built over time. Far more easily, in fact, than most humans do.
This observation, seemingly trivial, overturns a common intuition. We often expect an assistant to tell us how to do things. Yet what matters most plays out beforehand: in the quality of the foundations we give it to follow.
AI exploits your standards remarkably well
The standards built up over time (code conventions, architectural choices, recurring design patterns, security rules, documentation) are broadly very well exploited by LLMs. Give an agent a healthy, consistent, readable codebase, and it will naturally extend it. It picks up on your abstractions, reproduces your idioms, respects your module boundaries. It behaves like someone who read your code carefully before touching it.
This is precisely where the underestimated advantage lies. Where onboarding a newcomer takes weeks (where you have to negotiate, explain, correct pull requests), the agent absorbs these conventions almost instantly, provided they’re readable and usable.
Alignment between humans remains the prerequisite
Ideally, you first seek to create this alignment on standards between humans. That’s far from easy, and the reality on the ground makes it clear:
- Everyone arrives with their own experiences, opinions, and preferences.
- Views diverge on how to solve the same problems, or worse, on the very perception of those problems.
- And sometimes, people simply don’t consult the standards already established.
The consequence of this lack of alignment is local divergences that, over time, widen the gap of entropy. Certain projects or certain modules adopt different approaches for unjustified reasons. The cost is paid the moment you need to move through the codebase: change teams or squads, and you’re back to square one. Zero bearings. Little or no imprint of a shared engineering culture. Perpetual debates that bring no value, because each time you replay decisions that should have been settled once and for all.
The amplification principle: the good as much as the bad
This is where the illusion dissolves. Unsurprisingly, if your code is a mess saturated with entropy, your AI agent will follow those rails too, with a wall at the end of the line. It has no reason to straighten out an incoherent trajectory; it extends it with the same diligence it would have applied to extending a healthy one.
The best way to capitalize on an assistant like Claude or Augment is therefore to first create alignment between humans, then make it usable so you can heavily delegate afterwards. Don’t count on your agents to lay the rails for you; count on them instead to advance with consistency along the ones you put in their path. An agent amplifies the good as much as the bad.
The image is that of a train. Lay down straight, well-maintained rails, marked out by your documentation, your ADRs, and your best practices, and it speeds toward the horizon. Let the rails break apart into chaos, and it derails just as efficiently.
What amplification produces in concrete terms
Personally, I recently boosted my productivity enormously on a well-structured project. Claude replicated complex variants of use cases already tackled in the past very easily and very quickly, like a genuine extension of the team’s brain, almost a full-fledged member. Stunning.
In this kind of context, I’m convinced it’s possible to double or triple the productivity of an experienced, skilled team, as soon as it has laid the right rails upstream. Not because the agent invents anything, but because it generalizes fast and well from an already coherent foundation.
Conversely, for teams not yet on good rails, AI agents won’t bring about a different outcome. They’ll simply accelerate the trajectory, in the wrong direction. Speed, without accuracy, only brings the deadline closer.
The future: amplify, don’t substitute
The future of software engineering isn’t the substitution of humans by AI. It’s the amplification of teams that know how to:
- establish the right foundations,
- define clear standards and make them usable,
- create alignment between humans,
- and then, only then, delegate to AI agents.
The order of these steps is non-negotiable. Reversing the sequence (delegating first, structuring later) amounts to asking the agent to build on sand, then being surprised that the structure leans.
Conclusion
In short, bring in skilled, experienced software engineers, capable of creating this alignment: first for humans, then for AI agents. The goal isn’t to go faster by any means necessary, blindly handing the code over to a machine. The goal is to go fast, far, and in the right direction, which always presupposes, upstream, humans who knew how to lay the right rails.