Faster AI coding hits a review wall: what Kobie's CTO is changing
- Sayantan Mondal
- 850 views
Kobie Marketing's CTO found AI-generated code piling up in review. His fixes: testing first, tracking token use by outcome, and splitting ownership across teams.

Writing code was never the hard part for Ian Eshelman, CTO at Kobie Marketing. The bottleneck showed up downstream, in review. Engineers were producing more AI-assisted output, but the people checking it couldn't keep up, and the speed gained at the keyboard leaked away before anything shipped.


Where the time actually goes
Eshelman's summary is blunt. Engineers "thought they were actually running much faster when, in actuality, they were producing less because they were spending so much time generating review." That's the trap. Output volume is easy to see and easy to celebrate. Verification is slower and less visible, and it's where requirements, tests and security expectations actually get checked. As generation gets cheaper, verification becomes the constraint, and a productivity case that looked clean on a slide starts to look messier in the sprint.
My read is that this isn't really a tooling failure. It's a measurement question. If the metric is code produced, AI looks like a windfall. If the metric is features verified and delivered, the picture changes quickly.
Completeness before speed
Kobie's first response was to prioritise the completeness of software over how quickly individual components get produced. Eshelman points to behaviour-driven design and test-first automation, practices many teams know well but struggle to apply consistently. AI makes it easier to build fuller testing and regression coverage into the workflow, so changes can be assessed before they go out.
He describes this as the first horizon. The idea is to fully build a component within the time previously needed for a thinner version, and only then start cutting the time it takes to build. That sequencing matters. A more thoroughly tested component delivered in the same window as a rougher one is a real gain, even before development cycles get shorter.
Kobie tracks the effort needed to build features, including hours against relatively sized work, and asks whether comparable tasks are becoming less effort-intensive. Measuring the business value of that work is harder, and Eshelman is candid about it. His view of AI's impact has shifted over the past six months and may shift again. The benefits are still being evaluated, not reduced to a single productivity figure.

More tokens, not necessarily more value
Kobie also tracks token consumption across developers to see whether heavier model use leads to better engineering outcomes. Rather than imposing fixed limits on individuals, the company is looking at how usage relates to productivity at both the individual and team level.
The results don't show a consistent link between higher consumption and proportionate value. Some developers burn through far more tokens without commensurate gains, while others get useful benefit from moderate use. DevOps is the notable exception. Eshelman says higher token usage in infrastructure automation has produced capabilities Kobie didn't previously have.
That's the lesson for engineering leaders. Consumption alone can't measure AI's return. Teams need to separate three things: where AI reduces effort, where it improves quality, and where it makes work feasible that would otherwise have stayed impractical. Those benefits are related but distinct, and treating them as interchangeable overstates the productivity case.
Engineers who own outcomes
Eshelman doesn't expect software engineers to disappear. As agents take on more implementation, he expects their responsibilities to shift. "I think it changes what they do, but not necessarily who they are," he says. The emphasis moves toward deciding what should be built, defining requirements and working out how a solution sets itself apart. He also points to emerging roles that focus on building AI agents, alongside work centred on managing them.
For India's global capability centres, that shift has a sharp edge. If implementation becomes increasingly automated, adding headcount alone may not produce a differentiated technology capability. Teams will need people who can design systems, evaluate AI-generated work and judge which problems are worth solving.
Kobie's India technology hub reflects that thinking. The company set up the hub in July, and at the time of the interview it had about 50 people there, including AI engineers, data engineers and cloud engineers. Eshelman's stated intent is for teams in India to own design, architecture and implementation for their assigned domains, rather than executing work designed elsewhere. The company is working toward a roughly equal split between the US and India within its technology organisation. Its loyalty platform is divided into domains, with teams in each location accountable for their own area.
The distinction here is between distributing work and distributing responsibility. In the first model, one site finishes a stage and hands it on. In the second, a team owns a domain end to end. As AI changes how software gets produced, the second model matters more, because the value of a team increasingly rests on accountability for the system it delivers, not the volume of code it ships.
Agents still need boundaries
Autonomy introduces its own problems. AI agents that execute workflows need clear limits on what they can access and do. Kobie uses a builder, checker and validator model. One agent builds, another checks whether the output works correctly, and a third verifies that the requirements have been met.
The company also restricts what information agents can see. Eshelman describes an internal Model Context Protocol server that strips out personally identifiable information before anything reaches an agent. "We didn't want to say, hey, give the agent the same ability that that human has," he says. That separates an agent's ability to perform a task from its authority to access data or make decisions. More autonomous execution doesn't remove the need for controls, validation or human judgement.
So the productivity question and the governance question are becoming the same engineering problem. Faster generation has limited value if the resulting system can't be verified, controlled and trusted. For GCC leaders, the test isn't how quickly engineers can build with AI. It's whether they can pair human judgement with automated execution, keep meaningful controls in place and still own what comes out the other end.
Writing code has got cheaper. Owning what that code does is still the expensive part.