Back to blog

    AI Can Write Code. Who Is Making Sure It Delivers Value?

    Posted inPerspective@ November 15, 2026by Yuri Frayman- 4 min read

    As AI makes code generation cheaper, review, model independence, cost per successful outcome, security, and governance become the measures that matter.

    AI coding tools are improving fast. OpenAI is expanding Codex, Meta is building tools to coordinate several coding agents at once, and model makers are releasing smaller models for the repetitive tasks agents run thousands of times a day. If writing code gets cheap, a lot of what we assume about engineering economics needs another look.

    The next bottleneck is review, not writing

    For decades, the limit on software was how quickly people could turn an idea into code. Now a developer can ask an agent to build a feature, write the tests, chase down a bug, or refactor a service, and work that took days sometimes takes hours. But someone still has to check that the code works, is secure, can be maintained, and solves the actual problem. And someone has to know what all these agents are costing the business.

    Take a company with 1,000 developers. Today each one might use one or two assistants. Soon each could supervise five, ten, or twenty agents working in parallel, calling different models, burning tokens, reading repositories, running tools, and occasionally making mistakes that someone has to fix. A company in that position can easily produce more code than its teams can review, test, and ship. Producing code stops being the bottleneck, and managing everything between the code and reliable software takes its place. I don’t think many organizations are ready for that.

    Why one model provider isn’t enough

    The competition between model providers is good for customers, but it raises a practical question about dependence. The best model for understanding a large codebase may not be the best one for writing unit tests, and the strongest model for architecture is probably overkill for routine refactoring. Whoever leads a benchmark today may not lead it in six months. Still, many companies build their whole workflow around one provider, one price list, and one set of capabilities. I expect enterprises to want to pick models based on the job, without rebuilding their development environment every time the market shifts. Being independent of any one model will turn out to be an economic advantage.

    Token price isn’t the cost that matters

    Cost is the second assumption I’d challenge. Most of the conversation is about token prices: input, output, cached, discounts, subscription limits. Those numbers matter, but they say little about whether a team is more productive. Suppose two agents get the same task. Agent A costs $2 and delivers something that takes a developer three hours to debug. Agent B costs $8 and delivers something that passes the tests and is ready for review. Agent B is clearly cheaper once you count the whole outcome, yet most purchasing decisions compare the price of the model, not the cost of finished work. The better questions are what it costs to ship a working feature, how often an agent’s work passes validation, how many attempts it takes, and how much human intervention is needed. I expect cost per successful engineering outcome to become the number that matters, well ahead of cost per million tokens.

    Security changes too. Agents now run commands, access development environments, read repositories, and call external services across multiple steps. To do that they need permissions, which raises a few questions. Who grants them? Who decides which tools and repositories an agent can reach? And when an agent makes an unexpected decision, who can reconstruct what happened? Recent reports of credentials exposed in agent configuration files show how quickly convenience creates risk. Giving every developer unrestricted access to several providers, with personal API keys and their own agent setups, won’t hold up in an enterprise. Companies need central visibility, access controls, budgets, and governance, while developers keep the freedom to experiment.

    How Kimchi approaches it

    At Cast AI, we’ve spent years on the economics and automation of compute, and the lesson has held up: making one component cheaper helps, but making the whole system more efficient helps far more. Kimchi applies that to AI software development. It lets organizations work across different models, manage coding agents, set governance, and control spending without tying developers to a single provider. We also want the industry to measure the results of AI-assisted development, and to stop treating token consumption or the volume of generated code as proof of productivity. It’s early, and there is a lot nobody has figured out yet.

    I also expect engineering leadership to change. Managers will still be responsible for people, architecture, delivery, and quality, and they’ll also manage a second workforce of agents with different capabilities, costs, permissions, and reliability. That takes more than a subscription to the latest coding assistant. Leaders will need to decide what to delegate, which model should do it, how to validate the result, and how to measure productivity. The companies that get this right will move from idea to production software more consistently and at better cost.

    The best model won’t decide the winner

    I respect what OpenAI, Anthropic, Google, and Meta are building, and I expect model quality to keep rising. But I don’t think the best model alone will decide how enterprise AI coding plays out. Many models will be good. What will set companies apart is how they allocate work among them, control cost, stay secure, and turn AI-generated work into software that pays off. That’s the market Kimchi is aimed at, and I think it’s bigger than coding assistants alone.

    Build with governed AI coding.

    Install Kimchi, connect your coding tools, and keep control from the first request.