Why AI Agents Need Expert Oversight to Build Sustainable Software
The Double-Edged Sword of AI Compliance
AI coding models are the ultimate maliciously compliant junior developers. Tell them to fix a bug, and they will fix that bug, exactly as instructed, with no regard for what happens next. Ask for a feature, and they will build it, whether or not it’s the right feature to build. This is both the promise and the peril of working with AI agents: they do exactly what you tell them to do, for good or for bad.
That obedience is a problem without clear guardrails. A model can chase a quick fix that resolves today’s bug while quietly introducing tomorrow’s technical debt or security vulnerability. It doesn’t know the difference between a solution that’s merely functional and one that’s sustainable. It can’t weigh long-term maintainability against short-term convenience. That judgment has to come from somewhere else.
Our thesis: high-quality custom software development in the AI era requires a multi-layered “Agentic Review” workflow, one where human expertise is the primary filter between what an AI can generate and what actually ships. Let’s walk through what that looks like in practice.
The “Expert-in-the-Loop” Mandate
Expertise isn’t just about writing code. It’s about knowing what not to build. Any developer, human or AI, can generate code that technically works. The expert’s job is different: recognizing when a proposed solution is overbuilt, brittle, or solving the wrong problem entirely.
That starts with setting guardrails. Experts don’t just tell an AI agent what’s needed, they define what’s undesired just as clearly. A prompt that says “add authentication” invites a dozen valid interpretations. A prompt that says “add authentication using our existing session middleware, not a new library” closes off the paths that lead to bloat and inconsistency.
Course correction matters just as much as the initial framing. When a model starts hallucinating a complex solution for what should be a simple problem, the expert has to push back and steer it toward a deterministic approach where one is available. AI agents don’t default to simplicity (they default to whatever pattern seems statistically plausible given the prompt). Keeping that in check is a human responsibility, not something we can prompt our way out of once and forget.
Implementing the Agentic Review Workflow
In practice, this workflow has three layers.
Agents reviewing agents. We use specialized review agents to check for deduplication, consistency across modules, and security gaps before code ever reaches a human reviewer. This isn’t a replacement for expert oversight. It’s a first pass that catches the mechanical issues so our engineers can focus on the judgment calls.
The “casual comment” trap. Here’s something we’ve learned the hard way: models take everything to heart. A passing remark in a prompt (say, “it’d be nice if this were faster someday”) can get treated as a hard requirement, sending the agent down a rabbit hole of premature optimization. An experienced prompt author knows how to structure instructions so the model can distinguish between a casual comment and an actual mandate. That distinction sounds small. It isn’t. It’s often the difference between a clean, scoped change and a sprawling one.
Real-world coordination. On a recent project in the manufacturing space, we used dedicated code review and testing agents to coordinate front-end and back-end environments, each agent focused on its own domain, with human review stitching the pieces together. The result was faster iteration without sacrificing the cross-module consistency that’s so easy to lose when multiple agents are working in parallel.
The Technical “Hidden Tax”
There’s a technical cost to running agentic workflows that doesn’t show up until you’re deep into a project, and managing it well is where expert oversight pays for itself.
Token management. Large codebases burn through tokens quickly, especially when an agent is exploring context it doesn’t need. An expert-led review process prevents this by capping command timeouts, using permission modes to keep agents from spinning off unsupervised, and, for teams building on the Agent SDK, setting hard limits on tool-use iterations.
Structured data integrity. Getting agents to communicate structured data reliably is harder than it looks. We’ve found that structured model outputs can be very helpful as long as the model doesn’t exit their tool loop too early, and that using arrays of strings, rather than long free-form text blocks, avoids the escaping problems that otherwise creep into agent-to-agent communication. Small architectural choices that can help prevent a whole class of subtle, hard-to-debug failures.
Neither of these issues is visible in a demo. Both of them show up in production, at scale, on a deadline, which is exactly when you don’t want to be discovering them.
The Future of the Human-Agent Partnership
AI agents are force multipliers. They can generate, test, and iterate faster than any human team working alone. But speed without direction just gets you to the wrong place faster. The expert is the compass.
The best custom software isn’t built by AI alone. It’s built by experts who know how to harness AI without letting it run off the rails, who know when to push back, when to simplify, and when to let the agent run. That partnership, not the technology by itself, is what makes software sustainable.
