FinOps for Delegated Cognition: GitHub Boiled the Frog Backwards
Yesterday started with me staring at a tiny dashboard called CopeLimit.
This is not, admittedly, how most normal people choose to spend a Monday morning.
Most people, when confronted with a major billing transition from one of the largest software companies on the planet, probably go outside. Maybe have a coffee. Perhaps enjoy a hobby. Instead I was comparing API responses against CSV exports and trying to work out whether GitHub’s internal quota telemetry still lined up with the new AI Credits model.
Looking back, I think the funniest part of this entire episode is that my instinctive reaction to GitHub’s billing migration wasn’t anger. It was instrumentation. Somewhere deep in the cloud-engineer portion of my brain, a tiny voice immediately asked:
Cool. Where are the metrics?
Which is how I accidentally spent part of my Monday building observability around delegated cognition while LinkedIn was busy debating whether GitHub had become the villain of the week. The original purpose of CopeLimit was fairly modest. At the time I thought I was building a panic meter.
In hindsight, I may have accidentally started building the first dashboard for delegated cognition. How many requests do I have left? When does the quota reset? Am I about to discover halfway through a coding session that I’ve accidentally burned through an entire month’s allowance arguing with a coding agent about TypeScript?
Simple and useful questions that become significantly more interesting when somebody changes the rules, like GitHub just did.
While I was busy comparing quota values, billing reports, usage counters and API payloads, LinkedIn was having what can only be described as an entirely calm, measured and proportionate reaction. In other words, complete bedlam. Everywhere I looked there were screenshots of cancelled subscriptions, announcements of migrations to Claude, declarations of loyalty to Cursor, OpenRouter recommendations, think-pieces. Hot takes, cold takes and lukewarm takes that somehow managed to contain the same amount of outrage as the hot ones.
At first I assumed this was fundamentally a pricing discussion, but the longer I watched, the less convinced I became. Pricing was the trigger, but surprise was the story. And for reasons that probably only make sense if you’ve spent too many years watching cloud providers, software vendors and streaming services annoy their customers, that immediately made me think about Netflix.
Nobody enjoys paying more for Netflix than they did last year. Nobody receives an email announcing a subscription increase and thinks, “Fantastic. I was worried my monthly expenses weren’t growing quickly enough.” The same is true of Spotify. Amazon Prime. Disney+. Cloud providers. Nobody has ever opened an Azure invoice and described the experience as uplifting, and yet somehow these companies survive. The reason is surprisingly mundane - they understand change management. The frog starts in cold water and the temperature rises gradually so that customers have time to adjust. And then, somewhere around this point, I realised what had actually been bothering me - GitHub hadn’t really made an economics mistake, so much as they’d made a change-management mistake. They boiled the frog backwards.
Instead of gradually teaching users how AI Credits worked, gradually exposing cost signals, gradually surfacing usage telemetry and gradually nudging people towards the new mental model, they effectively picked up the frog, launched it directly into boiling water and then appeared mildly surprised when the frog immediately attempted orbital re-entry. That’s the thing I think much of the discussion has missed.
The economics and the rollout are not the same conversation. In fact, it’s entirely possible that GitHub are right about the economics and wrong about the transition; both statements can be true simultaneously. The funny thing is that I don’t actually think GitHub are wrong about the economics. There. I’ve said it. I know it feels vaguely heretical given that LinkedIn currently resembles a support group for recently traumatised Copilot users, but the more I thought about it, the more I kept arriving at the same awkward conclusion:
Somebody was always going to have to pay for this. Not eventually, not theoretically, but literally. Every time a coding agent decides it would quite like to read half your repository, inspect seven files, run a validation cycle, change three lines of code and then explain itself in four thousand words, somebody pays for that. For years the industry largely hid those costs because getting developers to build AI into their daily workflow mattered more than optimisation.
Mission accomplished.
Update: The transition period is more complicated than it first appears. Business and Enterprise customers receive promotional AI Credit allocations through August 2026 that are substantially higher than their long-term included allowance. This means many organisations are currently measuring usage against a temporary subsidy rather than the steady-state model. The true economics of GitHub’s new billing approach may not become fully visible until September 2026.
The awkward conversation starts afterwards, when somebody from Finance eventually arrives carrying a spreadsheet and asking questions nobody wants to answer.
A few people have described the situation as drug dealer economics and there is an element of truth to that as you get people hooked, hand out freebies, build dependence and then start charging. Technology companies have been running variations of the same playbook for decades with free tiers, cloud credits, founders pricing, introductory offers and generous limits - it’s hardly a revolutionary concept.
But I think that explanation is incomplete.
A drug dealer’s marginal cost is tiny but AI’s isn’t. Every heavy user creates genuine infrastructure costs and that’s what makes the whole discussion so messy. The cynical interpretation isn’t completely wrong, but neither is the economic one. Companies absolutely want adoption and lock-in, but they also eventually need the numbers to make sense.
What fascinates me is how many people seem to believe this is a uniquely GitHub problem. I don’t think it is though, I think GitHub simply arrived first. Some people have responded by immediately cancelling Copilot and moving to Claude, which is completely rational if your objective is reducing your bill this month. Whether it remains rational in two months or two quarters is a rather different question. Because unless Anthropic have secretly discovered a source of infinite free compute hidden beneath San Francisco, they’re eventually going to run into exactly the same challenge, as will OpenAI, Cursor and Windsurf.
Every provider in this space ultimately has to answer the same deceptively simple question:
What does it cost to support somebody who spends eight hours (or more) per day attached to frontier models?
The exact pricing structures will differ. The marketing language will differ. The degree of subsidy will differ. The underlying physics won’t. You can postpone economics for a surprisingly long time but you cannot postpone them forever. Oddly enough, the thing that grabbed my attention wasn’t the bill. It was the lack of observability. Or perhaps more accurately, the mismatch between the bill and the observability.
Most people’s reaction to usage-based billing was:
How much is this going to cost me?
My reaction was:
Where’s the dashboard?
Show me a meter and I immediately want to know what produced it. GitHub’s reports tell me how many credits I used. Great. Doing what? Which repository? Which branch? Which model? Which task? Which validation cycle? Which review pass? The bill tells me something happened. It doesn’t tell me the story. And the moment I realised that, the whole thing started feeling remarkably familiar. Because cloud computing went through exactly the same evolution.
First came the invoice. Then came the panic. Then came tagging, chargeback, showback, anomaly detection, dashboards and eventually FinOps. None of those disciplines appeared because engineers suddenly developed a love of accounting. They appeared because people needed to understand the bill rather than simply receive it.
AI feels like it is entering exactly the same phase. The bill has arrived but the observability is lagging behind and the next few years are likely to be spent building the tooling, practices and governance models that bridge that gap. Which brings me, somewhat accidentally, back to AADLC.
One of the funniest side effects of the AI Credits transition is that AADLC keeps wandering into domains I never intended it to solve. AADLC wasn’t created as a cost-management framework or a FinOps framework. It certainly wasn’t created because I thought one day I’d be writing a blog post containing the phrase “FinOps for Delegated Cognition” with a straight face. The goal was simply to stop coding agents behaving like caffeinated Labrador puppies that had somehow gained access to a Git repository.
Then AI Credits arrived and suddenly those same controls started producing something unexpectedly valuable: measurements. Planning consumed something. Implementation consumed something. Review-hardening consumed something. Validation consumed something. Repository hydration consumed something. The units weren’t consistent and the measurements were often rough, but for the first time it became possible to separate productive work from expensive wandering.
Which means, quite accidentally, AADLC started behaving like a FinOps framework. I did not have that on my bingo card. The biggest lesson I’ve taken from the first full day of AI Credits isn’t that AI is expensive. It’s that unstructured AI is expensive. Those are radically different statements. One implies a technology problem, while the other implies a workflow problem. Cloud engineers learned this lesson years ago: unlimited resources encourage waste whereas metered resources encourage architecture and AI is beginning to reteach exactly the same lesson.
Looking back, the really funny thing is that GitHub may have done the entire industry a favour because every other provider now gets to watch the frog hit the ceiling and quietly make notes. GitHub gets the outrage, the cancellation screenshots, the angry posts and the think-pieces. Everyone else gets a free lesson in change management. The economics may turn out to be entirely reasonable but it’s the rollout that people will remember. And that’s the lesson.
The more I think about it, the less this feels like a story about GitHub and the more it feels like a story about AI growing up. For years AI felt like “magic” (it was certainly marketed as such, unsurprisingly, for that’s what marketing people do). Magic doesn’t need governance, nor observability, nor FinOps, but infrastructure does. And whether we like it or not, we’re increasingly treating cognition as infrastructure.
That’s a ridiculous sentence but it’s also increasingly true; the moment organisations start spending meaningful amounts of money on delegated cognition, the same questions always appear.
- What consumed the budget?
- Was it worth it?
- Could we do it more efficiently?
- Who owns it?
- How do we govern it?
Those aren’t AI questions though, they’re infrastructure questions. Yesterday started with me staring at a quota meter and wondering whether CopeLimit still worked after a billing migration and ended with me thinking about cloud economics, governance, observability and the possibility that we’re watching the birth of an entirely new discipline. Cloud computing gave us FinOps because infrastructure became programmable. AI will probably give us something similar because cognition is becoming programmable, which sounds completely bonkers. Yet somewhere between GitHub’s billing migration, AADLC, CopeLimit and several thousand angry LinkedIn posts, we may have accidentally witnessed the first genuinely mainstream glimpse of FinOps for Delegated Cognition.
Not because anybody planned it.
Because economics showed up.
Economics always shows up.