This deep dive expands on the Loop Asia conversation with Manjunath Bhat, Distinguished VP Analyst, Gartner.

Every organisation moving agentic coding toward production hits the same wall, and Manjunath Bhat named it precisely: you cannot review every line of code an agent produces. Not inconvenient — implausible, at the volumes these tools generate. "You would very soon find humans as the new bottleneck," he said. For a CTO scaling agentic coding across a team, that sentence is the design problem. Bhat's answer isn't more human review — it's a verification architecture that scales the way generation did.

The orchestrator, and the problem with grading your own homework

The pattern Bhat is seeing in tools like Amazon Kiro and Cursor is a move from single agents to orchestrator-plus-sub-agent structures, where one sub-agent's job is to check what another produced.

The obvious failure mode is an agent grading its own homework: if the same model writes the code and reviews it, its blind spots show up in both places. Bhat's mitigation is model diversity by function, not just by task — one model, he floated something like GPT-5.x, as the coding sub-agent; a different model, Claude Opus-class, as the verifier. Neither is inherently better; two models with different failure modes checking each other catch more than one checking itself. That's a pipeline policy: decide which model class generates, which verifies, and let them diverge on purpose.

The inner loop and the outer loop have to move together

Bhat frames the requirement this way: "the success with these agentic coding tools is directly proportional to the degree to which we have a very high degree of verification and validation maturity." His formulation — a fast inner loop requires a faster outer loop — is asymmetric by design. Speeding up code generation is the easy half. The hard half is making test harnesses, validation gates, and CI scale at the same rate, or the gap between "code generated" and "code verified" widens every sprint until it becomes the bottleneck itself. Leaders measuring ROI on lines shipped: without matching investment in validation, you're moving the backlog from "code not written" to "code not verified," not accelerating.

Specs as governance, not as a guarantee

Bhat draws a distinction vendor pitches collapse: spec-driven development is not a spec-fulfilling agent. Agents are non-deterministic, so a specification doesn't guarantee compliance. What it does give you is a way for governance teams to codify standards once and have them travel with every agent session — his example, a platform or security team's policies written into a markdown file a tool like Claude Code reads at the start of every interaction. Same instinct as an API contract, applied to an agent's operating boundaries.

Paired with this: something Bhat didn't expect to say twenty years after Fowler's Refactoring was published — refactoring is having a resurgence, because generated code needs continuous compensation to stay maintainable. Budget for it to matter more, not less.

Where context becomes the real innovation surface

Bhat's closing point: the next competitive advantage isn't the experience layer — chat interface, IDE integration — it's the context layer. As tools plateau on how good the interaction feels, the differentiator becomes how well an agent understands your systems, standards, and data. That's the same question Blue Connector has spent years helping technical leaders answer, just with a new client: what does your integration and data layer need to expose, to whom, under what governance. The consumer used to be a mobile app. Increasingly, it's an agent — same discipline as the markdown file governing its behaviour, aimed at what it's allowed to see instead of what it's allowed to do.