Agentic Coding Needs an Air Traffic Control Shift Model
The strangers keeping your flight alive work in short, paired, exhausting shifts. Your developers don't. That is goin...
AI Agents Make You a Software Company
8 min read
The Old Warning Got More Expensive
16.07.2026, By Stephan Schwab
In 2012 the uncomfortable point was simple: if software becomes critical to your business, you do not get to pretend it is somebody else's craft. In 2026 the excuse changed, not the obligation. AI agents are now being sold as the way to raise output, cut headcount, and let vendors, operations teams, or business specialists build serious systems without strong software developers nearby. That pitch sounds efficient right up until the bill and the risk arrive together. Once agent work is metered, heavy usage stops looking like a toy budget. At current Sonnet API pricing, 30 million output tokens alone can mean roughly 450 dollars before you even count input, retries, or tooling overhead. That is one hard-driving user, not a fleet. Scale the pattern to a small team or an always-on agent workflow and you move from hundreds to thousands fast. Scale it badly and you get horror stories like OpenClaw, where a public 30-day dashboard showed about 1.3 million dollars in OpenAI spend across a large autonomous agent setup. And the invoice is still the smaller problem. The real cost is organizational. If people use agents to change production systems, redesign workflows, or reshape core processes, then the company is not merely buying AI tooling. It is operating a software capability and getting charged in real time for every weakness in judgment, architecture, testing, and ownership. AI agents do not save you from becoming a software company. They make the consequences of pretending otherwise arrive faster. Where does AI experimentation stop and owned software begin in your company?
As I wrote back in 2012 in When Your Organization Is a Software Company, companies that treat software like a side purchase are fooling themselves. If the software is strategic, then you are not merely buying a tool. You are stepping into the business of software whether you like the label or not.
That argument aged well. It also aged into a nastier environment.
Now executives see AI agents, a few smooth demos, and a dozen LinkedIn prophets swearing that software teams are optional. The fantasy writes itself. Give the product manager a smart assistant. Let operations generate integrations. Let the business analysts orchestrate the workflows. Let the vendors keep the hard parts. Keep a few developers around for cleanup. Pocket the savings. Present the result as modernization.
That fantasy was already wrong before agentic coding. It is even more wrong now.
AI Won’t Run Your Company by Itself made the strategic point already. The newer detail is financial and operational. Since the shift toward pay-per-use pricing, intensive model usage is no longer hidden behind a flattering flat subscription. And for agent-heavy work, that subscription path often is not the real operating model anyway. The old story that somebody could spend 200 dollars a month and vibe-code an entire ERP on the side is over. At current Anthropic API pricing, Sonnet output is 15 dollars per million tokens. Burn through 30 million output tokens and you are already around 450 dollars before input tokens, retries, browser context, or orchestration overhead. Put that behavior into a team workflow and the bill stops looking cute very quickly.
That does not make agents a bad investment. It makes them what software capability has always been: leverage that punishes amateurs.
The Bill Does Not Buy Judgment
"Paying for tokens is not the same thing as building competence. A metered model just invoices your confusion more accurately."
A surprising number of executives still think the hard part of software was the typing.
That belief survived outsourcing waves, low-code sales decks, no-code promises, offshore miracles, and every framework boom that was supposed to make serious development interchangeable. Now it has attached itself to AI agents.
But the expensive part was never the keystrokes. The expensive part was deciding what should exist, what should not exist, what must be tested, what must be left boring on purpose, and what hidden dependency will explode six weeks after the demo.
AI agents change the shape of the work. They do not remove that burden. As AI Makes Great Developers Dangerous argues, the abstraction moved upward. The agent handles more clerical work. That makes the remaining human decisions more concentrated, not less important.
Which means the organization now needs stronger software judgment while many leaders are budgeting as if they need less of it.
That is the real management trap.
The monthly invoice looks like tooling. The actual commitment is organizational.
Once your people rely on agents to change production systems, shape customer journeys, refactor core processes, or redesign internal operations, you are running a software shop. Not a metaphorical one. A real one. You need standards, tests, architecture discipline, repository hygiene, deployment discipline, and people who can say no to plausible garbage before it reaches customers.
If you do not build those capabilities, the agent does not rescue you. It just writes more of the mess before lunch.
Pay Per Use Kills the Last Cute Story
"Flat subscriptions let executives pretend AI was a toy budget. Agent workflows usually get metered instead."
The 200-dollar subscription story supported a lot of nonsense.
It encouraged the comforting little myth that software capability had finally become cheap enough to improvise. Some founder in a weekend. Some department head with ambition. Some operations lead with a prompt library. Why hire experienced developers when the machine now writes code and the subscription fee looks smaller than a software conference ticket?
That myth was always built on selective accounting.
People ignored the cleanup, the rework, the dead branches, the silent defects, the accidental architecture, the integration failures, the missing tests, and the opportunity cost of building the wrong thing quickly.
Pay-per-use pricing makes that harder to hide.
Now the waste shows up in two places at once.
First, it shows up in the codebase, where undisciplined agent usage can fill a repository with contradictory abstractions at industrial speed. Vibe Coding Isn’t Software Development was not written for nostalgia. It was written because systems still have to hold together after the demo people go home.
Second, it shows up on the invoice. Repeated long-context runs, retries, parallel agent sessions, and premium-model usage turn bad software judgment into a measurable operating cost. OpenClaw provided the grotesque public version: a 30-day dashboard with about 603 billion tokens, 7.6 million requests, and roughly 1.3 million dollars in OpenAI spend across a large autonomous coding setup. Most teams will not hit that scale. That is not the point. The point is that metered agent usage makes waste visible long before the architecture is stable.
There is something healthy about that.
A few hundred dollars for one hard-driving user is not the scandal. A few thousand for a small team is not the scandal either. The scandal is burning that money while pretending you no longer need people who understand software.
AI Agents Create a Staffing Problem, Not a Staffing Escape
"Agents reduce clerical load. They do not eliminate the need for developers. They raise the value of the developers who can direct the system."
The executive temptation is obvious. If one strong developer with good agents can do the work of a small older team, then maybe the answer is to cut the team and keep the prompts.
That is the kind of conclusion people reach when they notice leverage but fail to notice where the leverage comes from.
A capable developer with agents is not powerful because the agent is magical. That developer is powerful because experience lets them frame the task, trim the context, reject nonsense, spot hidden coupling, test the right behavior, and stop before the repository turns into an archaeological site.
That is exactly why a subject matter expert with an AI agent still does not replace a real software developer. The SME may know the business rules. The agent may produce code, screens, and plausible explanations. But neither of them necessarily knows how to shape a maintainable system, test critical behavior, control dependencies, or see where a cheerful prototype is quietly turning into operational debt.
Someone without that depth can also move fast. They usually move fast toward a pile of outputs nobody can really own.
The staffing consequence is awkward for management theater.
You may need fewer people doing repetitive implementation. You may also need more senior judgment per unit of shipped change. You need developers who can hold product intent, architecture, delivery risk, and business consequence in one conversation. You need them close to decisions, not parked behind tickets.
That is what becoming a software company looks like in 2026.
Not a giant department full of ceremony. Not a shrine to headcount. A business that accepts software as a core capability and staffs accordingly.
The Real Cost Is Organizational Cowardice
"The dangerous bill is not the model invoice. It is the compound cost of executives using agents to postpone learning how software actually works."
The old 2012 question still holds.
Are you willing to become a software company?
In 2026 there is a sharper version underneath it.
Are you willing to admit that AI agents do not let you skip the transformation?
Because that is what many organizations are trying to do. They want software leverage without software discipline. They want AI speed without developer authority. They want system change without architectural responsibility. They want the result without the profession.
That combination does not get cheaper because the interface looks friendly.
It gets more dangerous.
The agent will politely produce options. It will summarize modules. It will suggest migrations. It will explain errors in a tone that flatters the reader into trusting it. It will keep working late without complaint. All of that makes it psychologically perfect for organizations that already underestimate software.
The machine looks obedient. Reality is not.
If the business depends on software, then agentic tooling does not reduce the importance of software leadership. It raises it. You need fewer fairy tales about democratized coding and more adult decisions about where software sits in the business, who owns quality, how changes are tested, which repositories are trustworthy, and where expensive models are actually worth the spend.
That is the follow-up to the old warning.
You are not escaping the software company question.
You are just being charged by the token while you avoid answering it.
Talk It Through
Tell me what is happening. I listen, ask a few practical questions, and reflect back what I see: where the risk may sit, what may be blocking delivery, and what looks worth checking next. No pitch, no obligation. Confidential and direct.
Talk it through. Practical reflection, no pitch.
Start a Conversation
🎭 This Week's Episodes
Telenovelas show what we can't say in client meetings. The drama is heightened, but the patterns are real.
The Live Launch
The tournament system goes live in production for the August event. When a sudden network partition splits the EU and US clusters, the team's new a...
The Run Tells the Truth
Ethan Carter turns the harness into a habit: every change runs the batch in daylight, and the Cucumber scenarios refuse to lie. Nathan Cole feels s...
Technical Consultancy
Embedded Delivery Partner
Embedded into your team as an active contributor, reducing delivery friction and helping important work move cleanly.
Technical Advisor
Peer-style technical assessments before far-reaching decisions; reduce architectural and product risk early.
Product & Delivery
Ship working software to real users earlier. Measure impact and adapt based on evidence rather than assumption.
Custom Software Development
High quality, maintainable software. Short-term augmentation that leaves lasting capability in your own team.
Recent Articles
- AI Agents Make You a Software Company (16.07.2026)
- You Never Needed a Fad to Invest in Your People (11.07.2026)
- Agentic Coding Needs an Air Traffic Control Shift Model (07.07.2026)
- What Governance Actually Means (03.07.2026)
- AI Needs Developers, Not Just Data Scientists (29.06.2026)