The Senior Engineer Whose Week Disappeared Into Somebody Else's Agent

GitHub moved Copilot Enterprise to usage-based billing on 1 June 2026, pricing each seat at $39/month with $39 of pooled AI Credits. The announcement carried a sentence the finance director at a series-B software company filed for later: "the credits pool across the organization, agentic workflows drink from that pool at a rate no seat count predicts, and anything beyond the pool bills on top".

She received the September invoice four weeks ago. The platform line that ran $28,080 in May, 60 developers at $39 each plus GitHub Enterprise Cloud underneath, came back at $71,200. No headcount change. No platform change. A launch allowance that gave Enterprise seats $70 of credits from June to August fell to $39 in September, and usage that the subsidy had hidden now sat on the bill in full.

The meeting she called with the head of engineering turned on a question neither could answer from the invoice: which developer consumed what, and doing what task. GitHub's dashboard segments usage by team and shows aggregate credit burn, but the unit it measures is the token, and a token is an abstraction five layers below the thing her mental model wants, which is the feature that justified the expense. The conversation ended where these conversations now end. She imposed a ceiling, $75,000/month at the organisation level with overage capped, and the engineering leader left to decide which team's agents stop mid-task when the pool runs dry.

The CTO at a logistics platform hit the same ceiling from the opposite end. Cursor Teams seats renewed in September at a rate four to five times the prior contract, the difference driven by agent mode and premium model selection that annual billing had metered differently. Cursor's June 2026 pricing update introduced Premium seats at $120/user/month, five times the Standard allowance, after noting the changes would lower costs for 90% of teams. He was in the other 10%, and the bill arrived before finance had modelled it.

The pattern is now showing in enough September closes that it has a name in finance Slack channels: the agent invoice surprise. The sticker said per-seat. The bill said per-seat plus usage, and usage moved faster than the forecast because the seat stopped being a person and became a pool that agents, co-pilots, and review bots draw against whenever a developer types a prompt or an automated workflow picks a frontier model.

Measuring the work when the chair is empty

PR size rose 51.3%, files edited per PR climbed 59.7%, and bugs per PR increased 54% under high AI adoption, according to Faros's AI Engineering Report covering 2026. The developer who opened the pull request worked fewer hours to produce it, which is the productivity gain the tool's marketing promised and the velocity metric the dashboard confirmed. The senior engineer assigned to review it worked longer.

Median time to first PR review rose 156.6%, average time in PR review jumped 199.6%, and median time in review climbed 441.5%. The same Faros dataset found teams using AI coding tools completed 21% more tasks and merged 98% more pull requests, but PR review time increased 91%. Individual output went up. Organisational throughput did not, because the review queue has not grown incrementally, it has broken.

A staff engineer at a series-C SaaS company described her week in a post that circulated widely enough to become the archetype. Monday morning: 14 pull requests in the queue, five flagged for her because they touch the authentication service she wrote. Two are straightforward: dependency bumps, obvious logic fixes, 40 lines each. Three are agentic refactors, 180 to 240 lines, crossing four files each, with commit messages that read like feature completions but implementation details that suggest the agent misunderstood the invariant the original code maintained. Reading them carefully enough to decide whether they are safe takes her until Wednesday lunch. By then the queue holds 19 requests.

The time she used to spend designing the next quarter's architecture work now goes to reconstructing what an agent thought a junior developer's three-sentence prompt meant. The report describes this as the senior engineer tax. The people with the deepest knowledge of the system spend their most valuable hours unraveling plausible-looking code that should never have reached them in the state it did.

Finance cannot see this. The dashboard shows 21% more tasks closed, 98% more PRs merged, seat cost per developer down 15% if measured strictly on the per-seat line before usage. What it does not show is that senior engineers in 2026 report spending 20-35% more time on code review when juniors lean heavily on AI assistants, and that time is the scarcest resource the business owns.

The measurement that moves the bill and the measurement that moves the schedule

The finance director looking at the September invoice sees one number: total cost divided by developer headcount, which climbed from $468 to $1,187. The number she needs, and does not have, is cost per delivered feature weighted by the review burden that feature imposed on the constrained resource, which is the senior engineer's calendar.

The problem is structural. The AI coding tool sells itself on a velocity metric: tasks completed per developer per sprint, lines committed, PR throughput. All of those are individual output measures, and all of them went up. The bottleneck in a software delivery system is rarely individual output. It is review, integration, and deployment, the steps where work from multiple people collides and someone with system-wide knowledge decides whether it can ship.

Pull requests merged without any review, human or agentic, rose 31.3%. That does not reflect a deliberate decision to bypass oversight; the more likely explanation is that reviewers cannot keep pace with the volume of AI-generated code arriving for their attention, so code is reaching production systems with no oversight at a meaningfully higher rate than before.

A director of engineering at a 240-person product company ran the numbers after her team's cycle time lengthened for three consecutive sprints despite AI tool adoption climbing to 60%. She segmented cycle time by review queue depth and reviewer seniority. The four most senior engineers, those who could review changes to the payment flow or the async job scheduler, carried queues averaging 22 pull requests each. Developers with less than two years' tenure carried queues under six. Total PRs opened per sprint rose 47%. PRs touching core services, the ones only senior engineers could review, rose 62%. The load was concentrating exactly where capacity was fixed.

Her initial mitigation was mechanical: assign junior reviewers to any PR under 50 lines that does not touch the payment path, authentication, or the billing service. That bought two weeks. The PRs shifted larger instead of smaller, because developers using agents in multi-file refactor mode produce exactly the kind of change a junior reviewer cannot safely approve. Agentic AI PRs have a pickup time 5.3x longer than unassisted PRs, while AI-assisted PRs wait 2.47x longer, according to LinearB's 2026 Software Engineering Benchmarks Report.

She then tried the measure her finance counterpart asked for: per-seat budget caps on agent usage, $60/month per developer. Agents began stopping mid-refactor on the third week of the month. Productivity variance inside a sprint became unmanageable, because a developer could ship three features in week one and stall on the fourth in week three when the pool ran dry. She removed the cap and told finance the bill would average $82/seat going forward, which moves the annual spend on AI coding tools from $180,000 to $590,000 for a 60-person engineering team. Finance approved it because the alternative was visibly worse, but neither side can yet demonstrate that the $410,000 increment delivers $410,000 in margin.

The number that would matter and why nobody has it

The executive who signs the invoice wants a return denominator that matches the cost numerator. Dollars in, margin out. The tool provides activity metrics: PRs, commits, lines, acceptance rate, token consumption. The engineering team provides delivery metrics: features shipped, cycle time, deployment frequency. The gap between them is the question: did the feature that cost $X in agent time and required Y hours of senior review time to merge produce $X + (Y times loaded engineer cost) in customer value?

Nobody has that number, because tracking it requires stitching the usage-based billing event stream from the AI tool to the feature tag in the commit to the story in the backlog to the revenue or retention impact of the feature, and only the first link in that chain is instrumented by default. The finance director can tell you that Cursor burnt $11,400 in credits last month. She cannot tell you that $4,200 of that went to agents rewriting the onboarding flow, which reduced trial-to-paid conversion time by nine hours and is worth defending, and $3,800 went to speculative refactors in a reporting module the product team already decided to deprecate, which is waste.

The engineering director can tell you the onboarding PR took four days in review because it touched 11 files and changed an auth assumption, and the reporting refactor took 40 minutes because the senior engineer who owns that module is on leave and nobody else looked at it before merge. He cannot tell you what either consumed in AI credits, because the billing event does not attach to the repository metadata in a way his dashboard reads.

This is the coordination failure that makes AI coding costs invisible until they are not. The person who approves the tool purchase measures success in task velocity. The person who receives the bill measures cost in dollars per seat. The person whose time is the real constraint, the senior engineer in the review queue, measures her week in PRs she did not have time to read properly but approved anyway because the backlog will not clear otherwise. Those are three different units, none of them comparable, and the invoice reconciles to only one of them.

What the billing model is now teaching

Usage-based pricing has one pedagogical advantage over seat-based: it makes the variable cost visible. The seat price is fixed, but the bill is not, because usage beyond the pooled credits is charged on top, which is why the real Enterprise question in 2026 is not the price per seat but your engineers' token consumption. That sentence, buried in GitHub's transition documentation, is the closest thing to a forecast the vendor provided, and it turned out to be correct.

The finance directors who adapted fastest started tracking the credit burn rate weekly in July, before the September allowance step-down, and imposed caps in August so the surprise landed in a low-revenue month. The ones who treated the transition as a price-locked seat renewal received September bills that required board explanations. The difference was not analytical sophistication. It was recognising that the unit of cost had moved from headcount, which finance controls, to behaviour, which engineering controls, and the two groups do not share a dashboard.

One CTO told his finance counterpart in June that the team would "use AI responsibly and monitor usage." By September that monitoring consisted of a monthly Slack message reminding developers to avoid premium models unless necessary. Credit consumption was up 3.4x. When finance asked for the per-developer breakdown, engineering produced a CSV export with timestamps, token counts, and model IDs, which finance could not interpret without a rate card and a join key that did not exist.

The conversation that followed is now standard. Finance wants a pre-commit budget with hard caps. Engineering argues that mid-task throttling destroys productivity and the whole point of the tool is to remove friction. The compromise is a soft cap with alert fatigue, where the dashboard emails the channel twice a day and everyone ignores it until the bill posts. That is not governance, it is the performance of governance, and it stops working the moment the invoice crosses a threshold somebody's bonus depends on.

Where the line will settle

AI spend is moving to governed budgets; the blank-check era is over, and finance directors now expect per-user caps, mandatory ROI cases before approval, and procurement authority shifting from engineering to finance. That shift has a tell. In May 2026, 80% of the AI coding tool contracts a mid-market procurement platform processed were signed by a VP Engineering or CTO. In September, 60% required CFO co-signature, and 22% moved to finance-led vendor selection with engineering as a consulted stakeholder rather than the decision maker.

The contract structure is changing in parallel. Annual pre-pay with bundled usage is reappearing as the enterprise tier, because finance will pay a 15% premium over monthly usage-based billing to convert the variable cost back into a fixed one. Cursor and GitHub both now offer pooled enterprise credits sold as annual commits, and the attach rate on those deals has climbed every month since June. The finance buyer is trading unit-cost efficiency for budget certainty, which is the correct trade when the variable you are eliminating is engineer behaviour and the alternative is monthly reconciliation meetings where engineering explains why agent usage spiked and finance explains why the department is over budget.

The tool vendors are learning the same lesson SaaS infrastructure learned a decade ago: consumption pricing wins the first deal and kills the renewal unless you offer a ramp and a ceiling. GitHub's September credit step-down was mechanically correct, it ended the launch subsidy and returned to sustainable economics, but it created a cohort of customers whose September bill was 2.5x their June bill with no warning that felt like warning. Some of those customers are now in renewal conversations with alternative tools whose pricing includes a committed usage band with overages charged at a lower rate. The game theory is obvious. Surprise your customer once on the bill and they will shop the renewal twice as hard.

The senior engineer whose queue will not clear is not party to these conversations, and her calendar is the asset the business is spending down while finance and engineering argue about caps. She is billing 28 hours a week to code review, four hours to design work, and eight hours to meetings. Two years ago those ratios were inverted. The AI tool made her team faster at producing code and slower at shipping features, because the gating resource is her judgement and there are 168 hours in her week, 40 of them contracted, and the invoice pays for tokens but not for her evening and weekend reading to catch up on what she could not review during the day.

That is the cost the bill does not carry and the dashboard does not show. It will appear somewhere else, in attrition surveys, in delivery slippage, in production incidents that trace to PRs merged without adequate review because the queue was 30 deep and the sprint review was the next morning. By the time it is visible in a metric finance watches, the accumulation will be quarters deep, and the corrective will not be a billing change or a model cap, it will be a process redesign that treats agent-generated code as a draft requiring senior review before it enters the branch, which is the control that should have been in place in June and was not because everyone was optimising for velocity instead of oversight.

Tarry Singh is the founder and CEO of Real AI (realai.eu), an enterprise AI advisory and deployment firm working with global enterprises on production agent systems, model risk, and AI sovereignty strategy. He also leads Earthscan (earthscan.io) for Energy AI, and is a founding contributor to the EU-funded HCAIM and PANORAIMA programmes for responsible AI education across European universities. He writes at tarrysingh.com.