AI Can Write the Code. But Who’s Managing the Software?

Generative AI has changed the economics of software creation faster than most organizations have changed the way they manage it.

A developer—or increasingly, a founder, product leader or domain expert—can describe a feature and watch an AI create the database, write the API, design the interface, debug errors and generate tests. Work that once required a small team can now move from idea to functioning software in days or hours.

The amount of software we can create is about to explode.

But our ability to generate code is improving faster than our ability to govern what the machines are building. The next constraint will not simply be whether an AI can write a function. It will be whether people and organizations can maintain alignment, accountability, quality and economic control while machines make hundreds of development decisions at extraordinary speed.

AI can write the code. The more important question is: who is managing the software?

Two warnings from the frontier

Two recent essays by software engineer Tanmay Bansal capture opposite sides of the same emerging problem.

In “OpenAI Shocks The World With GPT-6”, Bansal describes a future of hierarchical memory and coordinated AI systems. The useful idea is not the headline or any particular rumor about an unannounced model. OpenAI had not publicly confirmed a GPT-6 product when the essay appeared, so claims about its architecture should be treated as speculation rather than product documentation.

The underlying design problem, however, is real. Long-running agents lose the thread. Immediate context crowds out the original objective. A system can solve the obstacle in front of it while drifting away from the outcome it was created to deliver. Bansal’s hierarchical-memory framing points toward a necessary separation: persistent objectives and constraints at one level, changing working context at another.

His second essay, “Why Microsoft and Uber Are Pulling the Plug on AI Agents”, looks at the economic side. It describes enterprises confronting unexpectedly high spending on agentic coding tools and responding with tighter controls, preferred tools and usage limits. Here too, the larger lesson matters more than any single company anecdote: autonomous work is not automatically economical work.

An agent can be productive and still be poorly managed. It can consume expensive reasoning on a trivial change, repeatedly investigate a failed hypothesis, recreate context it should already know or produce large amounts of code that never reaches a validated outcome.

Put the two essays together and a more important thesis appears:

AI development needs persistent direction above the agent and economic control around the agent.

Neither a better prompt nor a larger model solves that by itself.

The automatic gearbox was only the beginning

I previously argued that AI needs an automatic gearbox: a routing layer capable of selecting the right model, reasoning depth and cost profile for each job.

The analogy remains useful. A company would not assign its most expensive principal engineer to change three labels on a settings page. AI development should not send every task to the most powerful frontier model either.

Simple, deterministic work may require no generative model at all. Routine implementation can use a fast, economical model. Architecture, security analysis or a difficult production failure may justify substantially more reasoning power. Visual work, research and code can each benefit from different capabilities.

Developers should not have to make that allocation decision manually before every task. The system should know when it needs more power—and when it does not.

But a gearbox only manages the transfer of power. It does not decide where the vehicle is going, whether it is still on the road or whether it has arrived safely.

Model routing is therefore one component of a much larger requirement: an AI Development Control Plane.

From coding assistant to development control plane

Modern AI development is often managed through a loose collection of prompts, chat histories, tickets, documents and source files. Over time, that collection becomes the accidental definition of the product.

Important requirements get buried in conversations. A change satisfies the latest prompt but violates an earlier business rule. An agent reports completion because the code was written, even though the behavior was never tested. A second agent repeats an investigation because the first agent’s learning was not preserved in a usable form.

A development control plane would create a persistent layer between what an organization intends to build and the AI systems doing the work.

At a high level, it should maintain a living understanding of:

the product’s objectives and intended outcomes;
approved requirements and business rules;
architecture, dependencies and design standards;
the authority granted to each human or AI participant;
work in progress and its relationship to the original objective;
validation evidence, not merely completion claims;
resource consumption and the value produced by it;
durable lessons from useful successes and failures.

The implementation of such a system is more than a project dashboard with an AI assistant attached. Its purpose is to make intent operational: work should be planned, routed, executed and evaluated against a shared definition of what is being built and why.

The difference between activity and progress

Traditional software management already struggles to distinguish activity from outcomes. AI makes that distinction more urgent because machines can generate activity almost without limit.

Lines of code are not progress. Tokens consumed are not progress. An agent completing twenty steps is not progress if the steps no longer support the objective.

A control plane should make it possible to ask:

Why is this change being made?
Which requirement or objective does it support?
Why was this model or tool selected?
What has actually been validated?
What remains uncertain?
What did the attempt cost?
Did a failure produce reusable knowledge?

This creates a traceable chain from business intent to implementation and evidence. Not every small action needs executive review, but every meaningful action should remain connected to the outcome it serves.

That connection matters as AI systems become more autonomous. The faster execution becomes, the more valuable a stable source of direction becomes.

Failure is not necessarily waste

Cost control is often reduced to token limits. That is understandable, but incomplete.

A failed attempt can be valuable if it eliminates a plausible hypothesis, uncovers an unknown dependency or identifies the root cause of a defect. Engineering has always advanced through disciplined learning.

The waste occurs when a system cannot tell the difference between learning and repetition.

An agent that tries the same ineffective approach three times with slightly different wording is not exploring. It is spinning its wheels. An agent that repeatedly reloads the same background because no persistent context exists is paying a tax on organizational amnesia.

The right economic question is therefore not, “How few tokens did we use?”

It is, “What useful change in state did those resources purchase?”

That change might be validated software. It might be reduced uncertainty. It might be a documented constraint that prevents future agents from making the same mistake. Measuring value this way allows a system to spend more when a difficult problem justifies it and intervene when continued activity is no longer producing information.

Governance without a human bottleneck

Greater governance does not mean placing a person in front of every model call.

If a human must approve every routine decision, much of the speed and scale created by AI disappears. The objective is not constant supervision. It is bounded autonomy.

Organizations should be able to define objectives, standards, budgets, risk levels and authority boundaries. AI systems can then operate freely inside those boundaries while escalating the decisions that are novel, consequential or outside their authority.

A routine interface correction should not require approval for a modest model escalation. A proposed production database deletion should. The distinction should come from policy, context and risk—not from whether someone happened to be watching the chat window.

This is where persistent intent, intelligent routing, validation and economic controls converge. Each capability is useful alone. Together they begin to resemble the management system for an AI-native engineering organization.

The platform I am building

I am now developing a platform around this concept, initially shaped by the practical challenge of managing my own growing portfolio of AI-assisted projects. The goal is to make the resulting control-plane capabilities available to other AI developers and teams.

The project extends well beyond choosing a model from a menu. The routing “gearbox” remains important, but it sits inside a broader operating layer designed to keep objectives, execution, evidence and resource decisions connected throughout the software-development lifecycle.

The platform is intended to help answer a deceptively simple question at any moment: Are the humans and AI systems working on the right thing, in the right way, with evidence that it worked?

Some of the system’s orchestration and evaluation methods are necessarily proprietary and still in development. The public principle is straightforward:

The product—not the conversation—must remain the durable source of truth.

Agents will change. Models will improve. Development tools will come and go. A team should not lose its objectives, standards, decisions and accumulated learning every time the underlying AI changes.

That separation also creates freedom. When project intelligence lives above any single model, the system can select new capabilities as they emerge without rebuilding the project’s institutional memory from scratch.

What AI developers can do now

A complete control plane is an emerging category, but teams can adopt its principles today.

Separate durable intent from temporary context. Keep objectives, requirements and critical constraints somewhere more reliable than a long chat transcript.

Route work according to difficulty and risk. Do not use the same model, budget and review standard for every task.

Require evidence for completion. “Implemented” and “validated” are different states. Tests, observable behavior and review results should support completion.

Preserve useful learning. Record durable constraints and discoveries, not every action an agent performed.

Measure outcomes, not consumption alone. Cost matters, but cheap activity that produces no progress is still waste.

Define authority boundaries before execution. Decide which actions can happen autonomously and which require escalation.

These practices are not bureaucracy for its own sake. They are the scaffolding required to let AI operate with greater autonomy safely and economically.

The management layer becomes the product

Generative AI has dramatically reduced the cost of turning an idea into code. It may eventually provide something close to unlimited capacity to create software.

Unlimited capacity without direction does not produce unlimited value. It produces unlimited opportunities for drift, duplication, defects and spending.

The next major advance in AI development may therefore not be another coding agent. It may be the system that decides what the agents should do, selects the appropriate intelligence, preserves the objective, evaluates the evidence, learns from failure and knows when to ask a human.

The automatic gearbox helps choose the right engine for the job.

The control plane manages the journey.

Ideas and concepts: Lorenzo Vallone. Text drafted with AI assistance and reviewed by the author.

References

Tanmay Bansal, “OpenAI Shocks The World With GPT-6”, Artificial Intelligence in Plain English, July 31, 2026.
Tanmay Bansal, “Why Microsoft and Uber Are Pulling the Plug on AI Agents”, Artificial Intelligence in Plain English, July 10, 2026.