When Your Company's AI Bill Explodes, Who Pays?

The flat AI seat is becoming a meter, and the bill now moves with how hard your team works. Against the value of the work that number is almost always small. The costly mistake is rationing the people who use these tools best.

In June 2025, Cursor swapped its flat $20 seat for usage-based billing pegged to model API costs. Developers who ran large refactors woke up to overage charges they had not seen coming, and within weeks the company apologized and issued refunds. The product had not changed. The price of using it the way people actually use it had become visible. That gap, between the seat a manager budgeted and the meter the work was always running, is the whole story.

It is not only Cursor, and not only developers. GitHub Copilot started charging for premium requests in 2025 and moved every plan to usage-based, credit-metered pricing on June 1, 2026; Anthropic capped its heaviest Claude users in August 2025. Across enterprise software, the flat per-seat fee is in retreat. It was always a subsidy, funded by venture capital and by the light users who never hit their limits, and that subsidy is ending. When it does, a quiet line item becomes a number that moves with how hard your team works.

Disclosure: I use these tools daily. I work for Accenture, and the opinions here are solely my own.

The bottom line. A rising AI bill is mostly the tool working, because the seat is turning into a meter and the meter runs on productivity. Against the value of the work the token cost is small, so the spend is the wrong thing to fear. The real mistake is rationing: throttle the tool to save a rounding error and your best people leave for a company that does not. Treat AI as a variable cost with a measured return, show the spend to the team that creates it, and resource your people instead of capping them.

The argument, in one paragraph. AI tooling is repricing from the seat to the token, so the bill stops being a fixed subscription and becomes a variable cost that rises with productivity itself. The seat hid the real cost of heavy use, and heavy use is the use that pays off. Companies have a short menu of responses: ration it, meter it back to the team that spends it, gate it to roles that prove a return, prioritize the tasks worth the spend, or route work to cheaper or self-hosted models. Each lever moves the cost somewhere, and where it lands decides who carries the risk. The cheapest-looking move, giving people less of the tool, carries a cost that never shows on the books: the people who use these tools well leave for an employer who lets them. The bill is the easy question. Who absorbs the variance, and who keeps the gain, is the real one.

The short version.

For companies:

1. Treat AI as a variable cost. Forecast it with a variance band, the way you budget cloud or travel.
2. Show the spend to the team that creates it. Chargebacks turn an invisible line into a number an owner manages.
3. Match the model to the task, and let people choose. Make cost visible, give the frontier model where a mistake is expensive, and do not force a cheap default that slows your best people.
4. Set a budget band. Let heavy users run beneath a ceiling set by the value of the work.
5. Run cheap open-weight models in a closed environment. Self-hosted and walled off from any Chinese server, they cut the bill by an order of magnitude. The hosted Chinese services are off the table for company data.
6. Resource your people, do not ration them. The bill is a rounding error; the real loss is talent. Throttle access and your best people leave.

For employees:

7. Measure your own usage and payoff now. Run a holdout, log where AI helped and where it misled you, and bring a number to the budget conversation.
8. Read a company's AI access as a signal. Barely-there tools show how it will back your work; the places that resource you well are where you do your best.
9. Ask what happens at the cap. The answer reveals whether the policy came from someone who does the work or only sees the bill.

For both:

10. The bill is rarely the question; the gain is. Pin down three numbers, the share of the role AI touches, the uplift on that work, and the cost of checking it. Meter the spend, but meter the return beside it.

The numbers behind the panic

Start with the magnitudes, because they reframe the problem. Take a knowledge worker who costs a company $120,000 a year fully loaded, doing work the company values at roughly twice that, and give them an AI seat that runs $2,400 a year, the price of a $200 monthly plan. For that seat to lose money, the tool has to add almost nothing. The break-even is a little over one percent: if AI raises the worker's total output by about one percent, the seat has paid for itself. Measured gains on the tasks AI is good at run well into double digits, so clearing a one percent bar across the whole role is not a close call. At a twelve percent overall uplift, the seat returns about ten times its cost.

That one comparison carries most of the argument. The token bill is small against the value of the work, so the price of the tool is almost never the real question. An interactive version of this model runs alongside this piece; the claims below are the ones it makes plainest, and you can move the assumptions to see where they hold and where they break.

The rational ceiling on AI spend is high. If a one percent gain breaks even, the most a company can justify paying for a seat is the whole value that seat adds, more than twenty thousand dollars a year in the same example, roughly ten times a typical subscription. A power user whose bill quintuples is still inside the envelope. The right answer to a jumping number is a budget band, a working cap that lets heavy users run beneath a hard ceiling set by the value of the work, not a reflexive cap that trades real value for the feeling of control.

Verification is the cost that moves the math. The binding constraint is the time a qualified person spends checking the output, the line most business cases leave out. Put it back in and it outweighs the price of the model: in the base case, checking the work costs more than the AI does. A seat that drafts in seconds but needs senior review of every line can erase its own return. One lever cuts the cost: a cheaper model, even another vendor's, can do the first pass, grading the expensive model's output and flagging only what a person still has to read. That turns part of the verification tax from senior time into a few cents of tokens. It does not remove the human from high-stakes output, but it shrinks how much reaches them. The work worth pointing AI at is the work where checking is cheap. This tax is not fixed. As the models grow more reliable, the line that needs a senior signature moves: work that demands full review today becomes a spot-check tomorrow, and the verification cost falls with it. The direction is down, but the line moves by task and by model, so it is a number worth re-measuring at each renewal.

The real fear is the gain. Slide the productivity assumption toward zero and the whole case collapses at once. That is the source of the unease behind the exploding-cost story. Leaders fear the productivity the tool buys is illusory. The fear is reasonable, and it names the thing to measure: the uplift. A dashboard will show you the token price; the uplift you have to prove.

Replacing the worker is the wrong default. Run the same model on substitution and augmenting beats replacing until AI can do roughly a third of a role unsupervised. Below that line it is cheaper to make the person faster than to replace them, and most roles sit below it today. That is why the immediate question is who pays for the tool. For most roles today, the job itself survives.

These same magnitudes explain why under-resourcing people is the costly mistake. A $2,400 seat is one to two percent of a knowledge worker's loaded cost, a rounding error against the value the tool produces. Skimping on it to save that rounding error, and leaving your best people throttled, trades a trivial line item for the risk of losing them. The economics that make the seat cheap to fund are the same ones that make rationing it a false economy. The rest of this piece is about where the cost actually lands, and how to decide it on purpose.

Why the seat is becoming a meter

The mechanics are not mysterious once you see what a per-seat price was actually doing.

A seat is a bet that usage is bounded. Flat per-user pricing works when the cost of serving a user is roughly fixed and roughly equal across users. That was true for a calendar app and a word processor. It is not true for generative AI, where one user running long agentic sessions can cost the provider a hundred times what a light user costs, and the provider pays a real metered bill for every token to the model lab underneath. A flat fee across that spread means the light users subsidize the heavy ones and the vendor eats the tail. Venture funding covered the gap while the goal was growth. As that funding tightened and the labs raised their own prices, the gap had to close, and it closed by moving everyone onto the meter that was always running behind the scenes.

Agents multiply the tokens. The shift from chat to agents is the accelerant. A person typing prompts consumes tokens at human speed. An agent that reads a codebase, plans, edits across many files, runs tests, and retries does many model calls per task without a human in the loop. Picture a coding agent handed a failing test suite at 6pm and left to run. It reads the repository, drafts a fix, edits a dozen files, runs the suite, reads the errors, and tries again, looping until the tests pass or it gives up. By morning it has made thousands of model calls against a problem nobody watched, and the bill tracks the work, not the worker's attention. The unit of consumption stopped being the question and became the job, and the jobs got longer. This is why coding tools were the first to reprice, and why the rate limits and credit systems all appeared in the same months. The product got more capable and more expensive at the same time.

The cost is now visible, and the visibility is the shock. Before the repricing, almost nobody could tell you what a given employee's AI use cost, because the seat absorbed it. The new systems make it impossible not to know. GitHub now meters Copilot by the token cost of each model, so a heavier model or a code-review pass draws far more credit than a simple completion. Cursor's credits show a dollar figure ticking against the work. The number was always real. What changed is that finance can now see it, attribute it, and ask why it tripled. The panic is less that AI got expensive and more that it stopped being invisible.

The levers, and where each one moves the cost

A company facing a rising and volatile AI bill has a finite menu. The honest way to compare them is by who ends up holding the variance.

The first four levers keep the cost inside the company and try to make it controllable. They are the FinOps playbook arriving for AI: monitor consumption in real time, attribute it to an owner, set thresholds, and route work to the cheapest path that clears the quality bar. Done well, this is just ordinary cost discipline applied to a new input. The point is not to spend less on AI. It is to make the people generating the spend aware of its economics while they are generating it.

Three of these deserve a closer look, because they are where the real money and the real risk sit: routing to cheaper models, prioritizing which tasks deserve the spend at all, and the people question, which is less about who pays than whether your best people stay.

Spending less per task: cheaper models and the China question

The fastest way to lower an AI bill is to pay less per task, not to cut how much you use. Most routine work does not need the frontier model, and routing it to a cheaper one is the single largest lever most companies have. It is also the lever they use least, because reaching for the best-known model is easier than deciding which task actually needs it.

The spread is real, and the Chinese labs opened it. Open-weight models, DeepSeek above all, arrived showing performance close to the Western frontier at a fraction of the API price. When DeepSeek's R1 reached the market in January 2025, it undercut the leading US reasoning models by roughly an order of magnitude per token, and cheap open-weight models from DeepSeek, Alibaba's Qwen, and others have kept that gap open since. For a company running high volumes of routine generation, classification, or first-draft work, the difference between a model that costs cents per million tokens and one that costs several dollars is the difference between a manageable bill and a runaway one.

For a company, there is one safe way to use these models, and it is not the obvious one. Skip the hosted Chinese API. DeepSeek's hosted service routes inference through data centers in mainland China, and its terms reserve broad rights to keep and train on what users send. Within days of its January 2025 launch, hundreds of companies blocked the app over data concerns, Microsoft barred employees from the consumer version in May 2025, and US federal bodies including the Navy and NASA restricted it, followed by more than a dozen states and a proposed federal ban on adversary-nation models. For any company with regulated data, customer information, or a government relationship, sending data to the hosted service is a non-starter, however cheap it looks.

The usable path is to run the open weights yourself, in a closed environment. Because these models are open-weight, a company can download them and run them on its own infrastructure or a Western cloud, walled off from any Chinese server, so no prompt ever leaves its boundary. That converts a per-token bill into a fixed cost of compute. What it does not remove is the rest: the model's provenance, any behavior trained into it, the security review the weights still need, and the engineering to host and serve them at speed. Self-hosting trades a metered bill for a capital and operations problem, which is a good trade at high volume and a poor one at low. That swap, from a metered operating expense to a fixed capital and operations line, is more than an accounting change. It moves the decision out of a manager's tool budget and into procurement and infrastructure, with the longer approvals, security sign-offs, and depreciation schedules that capex brings. The bill gets smaller and the friction moves upstream.

So most companies end up running a mix. A vetted Western frontier model for the sensitive, high-stakes, and customer-facing work, and a cheaper open-weight model, self-hosted, for the high-volume routine work, with a rule about which task goes where. That rule is the prioritization question, and it decides most of the savings.

How prioritization actually works

If the bill scales with use, then deciding what is worth using AI for becomes the cost-control decision, and "let everyone use the best model for everything" is the most expensive policy available. Prioritization is the discipline of matching the cost of the tool to the value of the task. It runs on two axes at once: what the task is worth, and how expensive it is to check the output.

A workable scheme sorts work into three tiers.

• Frontier model, human-checked. The expensive tier. Reserve it for work where an error is costly and the value is high: customer-facing output, code that ships, analysis a decision rests on, anything regulated. Here the model premium and the senior review time are both earned by what a mistake would cost.
• Cheap model, lightly checked. Where most volume lands. First drafts, summaries, classification, internal scaffolding, the language-shaped grunt work. A cheaper model clears the bar, and checking is cheap because a wrong answer is cheap to catch and cheap to fix.
• No AI at all. The tier companies forget exists. Some work is better done by a script, a template, or a person, and paying a model to do it buys variance at a premium. If the task has one correct answer and a rule can produce it, the model is the wrong tool at any price.

Two rules make the tiering hold.

Verification cost belongs inside the decision. A task whose output is expensive to check should either earn the frontier model or stay off AI, because a cheap model whose every answer needs senior review saves nothing.

The choice belongs to the person doing the work, with the cost made visible, not a cheap default imposed from above. The operator knows which task needs the frontier model and which does not, and forcing everyone onto the cheapest tier slows down the work that needed the better tool and pushes people to route around the rule. Make the cost legible, give people the better models where the task calls for it, and let automated routing handle the high-volume rest by escalating only when the cheap model fails. Rationing by default saves a little money and costs you the trust of the people you most want using these tools well.

This is the same logic the vendors are now pricing in. GitHub's credit metering, where a heavier model or an agentic action burns far more of your monthly allotment than a simple completion, is a prioritization scheme imposed from outside. A company can wait for the vendor to ration its choices through pricing, or it can make the choices itself and keep the savings. The rule for the budget meeting is short: spend the expensive tokens where a mistake is expensive, and nowhere else.

Retention is the real employee risk

Start with the scenario that sounds scariest, because it is the one least supported by the evidence. Almost no company today tells employees to fund their own AI. The trend runs the other way: firms are absorbing costs that have outrun their own plans. Uber burned through its entire 2026 AI coding budget by April, four months after rolling Claude Code out to about 5,000 engineers at $500 to $2,000 per engineer a month, and its COO said he could not yet connect the spend to anything customers feel. The bill is landing on employers, not workers, and how to split it is mostly a hypothetical.

The risk that is real is quieter. The people who have learned to work with these tools will not stay where they are rationed. Most knowledge workers already bring their own AI to the job, which is less a billing question than a sign that they are out ahead of what their employer provides. Survey data backs the worry: in SHRM's 2026 read, 44 percent of HR chiefs said uneven access to AI tools raises attrition risk, and it falls hardest on early-career staff, the people who feel they cannot meet rising expectations without the tools. If your best engineer can barely use AI at work, you have shown them how much you intend to invest in their output, and a competitor that resources them fully is one recruiter call away.

The mistake is treating AI access as a cost to minimize rather than a condition for doing the work. A worker who feels throttled rarely files a complaint. They take the next offer. Under-resourcing your people does not show up on the books until it shows up in the exit interview.

If a company does drift the other way, capping the tool until people quietly top themselves up out of pocket, it stacks new problems on top of the retention one. Company work starts flowing through personal accounts outside any compliance boundary, which is shadow AI by another name. A divide opens between the people who can expense a $200 plan and the people who cannot, and it compounds into who gets ahead. And where the tool is effectively required to do the job, reimbursement law can make the cost the employer's anyway, as California's Labor Code section 2802 already does for cell phones and home internet.

The constructive move is the opposite of cost-shifting. Fund a vetted tool well, bring it inside the enterprise agreement, and treat broad access as table stakes for the work rather than a perk to ration. That keeps the data governed, the field level, and the people who can use these tools where you want them, which is on your payroll.

What the other side will say

• "Usage-based pricing is fairer. Heavy users should pay for what they use." True, and it is the strongest case for the shift. A flat fee really did make light users subsidize heavy ones. The catch is that in a company the heavy user is usually heavy because the work demands it, so charging consumption back to them without crediting the output they produce is half a calculation. Meter the spend, but meter the return next to it.
• "This is just cloud all over again, and we learned to manage cloud." Largely right, and it is the reason FinOps practices transfer. The difference is speed and volatility. Cloud costs scaled with infrastructure you provisioned deliberately. Agentic AI costs scale with how a model decides to solve a task, which is harder to forecast, so the variance band is wider and the surprises are larger. The discipline is the same; the error bars are not.
• "Letting employees bring their own tools respects their autonomy and speeds adoption." It does both, which is why so many companies are tempted. But autonomy and governance are not the same axis. You can give people choice inside a vetted, funded set of tools without sending company data into personal accounts. The autonomy argument is sound; it just does not require offloading the cost or the risk to get there.
• "We can't measure AI ROI well enough to gate anything, so caps are arbitrary." Measurement is hard, and anyone who claims a clean per-seat ROI number is selling something. But "hard to measure" argues for better measurement and a costed baseline, not for either an unbounded bill or a blanket cap. Start where the work is repetitive and checkable, where the return is least ambiguous, and gate from there.
• "Just switch to the cheap Chinese models and the cost problem goes away." The price gap is real and worth capturing, but not through the hosted Chinese services, which route your data through jurisdictions and terms most regulated companies cannot accept. That is why hundreds of companies blocked DeepSeek within days of its launch. The usable version is running the open weights yourself in a closed environment, which keeps most of the savings at the cost of the engineering to host them. Cheap is a starting point, not a free lunch.

What this cannot do

Three honest limits, because a serious argument states them.

First, no cost-control scheme can tell you whether the underlying use is worth it. The levers here move a known cost around and make it visible. They do not answer whether the productivity is real, and a company that meters and charges back a tool nobody should be using has only made a bad decision legible. The prior question, whether this work should use AI at all, sits in adoption strategy, not in cost control.

Second, the pricing is still moving. Every figure in this piece has a date on it because the plans are being rewritten quarter to quarter. The direction, from seat to meter, is stable. The specific caps, multipliers, and credit systems are not, and a plan built around today's exact numbers will need rechecking at the next renewal.

Third, none of this resolves the harder question underneath. If AI makes a worker more productive and the employer captures that value, then the fight over who pays for the tool is a small version of a much larger fight over how that value gets split. Cost control decides who pays the input bill. It does not decide who keeps the output gain, and that is the negotiation that actually matters.

The employer's handbook: test the assumptions before you trust the number

The model's verdicts move entirely with three soft inputs: the share of the role AI can touch, the uplift it produces on that share, and what it costs to check the output. Guess them and the budget is just a guess. Measure them and the budget is a decision you can defend. None of the three needs a research team. Each has a method an operator can run on one workflow in a few weeks.

Share of the role AI can touch. Start with a task inventory. Break the role into its recurring tasks and estimate the time each takes, from time-tracking, ticket systems, calendars, or a one-week diary the team keeps. Tag each task by the traits that predict AI value: language-heavy, repetitive, high-volume, and checkable. The time-weighted share of tasks that carry those traits is your augmentable share. The free version is the shadow usage already in the building: survey, with no penalty, where people reach for AI on their own, because where they reach is a map of the language-shaped work you would otherwise have to hunt for. Resist the round number. "About half" is a guess; "the 38 percent of a support agent's week spent drafting replies and summarizing tickets" is a measurement.

The uplift, the number to be rigorous about. This is the assumption most often inflated by enthusiasm, so it is the one worth a real experiment. The strongest design is a holdout: give the tool to a random half of a comparable team, withhold it from the other half, and compare output on a metric you fix before you start, whether tickets resolved, pull requests merged, cycle time, or documents shipped. A random holdout is the only design that separates the tool from the people using it, and it is how the 14 percent customer-support gain was actually measured. If you cannot randomize, stagger the rollout in waves and compare the groups that have the tool against those who do not yet, adjusting for the underlying trend. Three cautions keep the number honest. Measure real work, not a demo, because the headline "56 percent faster" came from one contained coding task and shrinks on messy work, sometimes below zero: a 2025 trial found experienced developers slower with AI on code they knew well. Measure quality beside speed, because faster but wrong is deferred cost, not uplift. And re-measure after a month, because the novelty effect flatters the first reading.

The verification cost. Time the checking. Have reviewers log the minutes they spend validating AI-touched output against comparable work the AI did not touch, and price the gap at the reviewer's rate, which runs high because the reviewer is usually senior. Track the catch rate beside it: how often the output is wrong, how costly the misses are, and what share has to be signed off before it ships. Price it per task, not per role, because some work is cheap to check, a draft you can skim, and some is expensive, a number a decision rests on. The same tool is a bargain on the first and a loss on the second. Before you spend senior time, try cutting the bill with a cheaper checker: a second, low-cost model, often a different vendor's, can grade the first model's output and surface only the cases a person still needs to read. It works best where errors are detectable, less so where the hard part is judgment. Watch one warning sign: as trust grows, people check less, and a falling verification cost can be a real efficiency or a rising risk you have stopped looking at. Audit a sample even after the tool has earned your confidence.

Run all three on a single workflow at once and you have more than three inputs for the model. You have a costed pilot that tells you whether to scale, which is the discipline the dismal pilot-failure numbers reward.

The employee's handbook: prove your own number

The budget conversation is coming, and the same three numbers that decide the company's case decide whether your seat survives a cut. You can build the evidence now, before anyone asks, and walk in with a number instead of a feeling.

1. Keep a usage-and-output log. Track the tasks you hand to AI, the time or output they return, and the work you would otherwise have queued or sent outside. When access is rationed, the person with a documented return keeps the tool; the person with an anecdote loses it.
2. Time yourself on real work, with and without AI. This is your own holdout. Take a recurring task, do some of it with the tool and some without, and record both the time and the rework. A number from your own week beats any vendor benchmark in front of a manager.
3. Log where AI is wrong, not only where it helps. Note the misses and what checking them cost you. Honesty about the failure modes is what makes the rest of your evidence credible, and it is the verification cost your employer is trying to estimate. You can hand them the answer.
4. Map your own augmentable share. List your recurring tasks and mark the ones AI touches and the hours they take. That is your slice of the model's first input, and it shows where pointing the tool next would pay.
5. Know which model the work needs. Learn where a cheaper model costs you quality and where it does not, so you can argue for the expensive one only where it earns its keep. It signals that you think like an owner of the budget, not just a user of it.
6. Treat AI access as part of your package. Tool access now weighs in how knowledge workers choose between offers. If it matters to your output it belongs in the compensation conversation, and a company that barely lets you use the tools is telling you how it will back your work.
7. Ask what happens at the cap. Before a limit is set above your head, ask what you are meant to do when you hit it mid-task. The answer tells you whether the policy was built by someone who does the work or someone who only sees the bill.

The shift from seat to meter is real, and it is not reversing. Companies that handle it well will treat AI as a variable cost with a measurable return and manage it like any other input, with a forecast, an owner, and someone accountable for the number. Companies that handle it badly will push the variance onto the people least able to argue back. If you work for one of those, start by measuring your own value, because the budget conversation is coming either way.

Sources and further reading

The repricing

• Cursor's June 2025 shift to usage-based pricing, the user backlash, and the July 4, 2025 apology and refunds (We Are Founders timeline; CloudZero, "Cursor AI Pricing," 2026).
• "GitHub Copilot is moving to usage-based billing," The GitHub Blog, 2025; GitHub Changelog, "Updates to GitHub Copilot billing and plans," June 1, 2026 (premium-request billing from mid-2025; all plans moved to usage-based, AI-credit pricing on June 1, 2026, metered by token cost, with user-level budgets).
• "Anthropic unveils new rate limits to curb Claude Code power users," Yahoo Finance / VentureBeat, July to August 2025; Anthropic (@AnthropicAI) announcement, July 2025 (weekly limits effective August 28, 2025; estimated under 5% of subscribers).

The pricing shift across enterprise software

• "AI Pricing Models: Per Seat, Per Token, Per Outcome, and Hybrid," CloudNuro, 2025.
• "Token Economics: The Atomic Unit of AI Value," FinOps Foundation, 2026; FinOps X 2026 keynote coverage (nOps; SiliconANGLE, June 2026) on chargeback, showback, and ROI thresholds.

Cheaper models and the China question

• DeepSeek's January 2025 launch and the per-token price disruption against US frontier models.
• "Hundreds of companies are blocking DeepSeek," TechCrunch, January 31, 2025; "Microsoft employees are banned from using DeepSeek," TechCrunch, May 8, 2025.
• US federal and state restrictions on DeepSeek (Navy, NASA, Pentagon; 17-plus states) and the proposed "No Adversarial AI Act" barring adversary-nation models from federal use, 2025.

The employee question: access, retention, and cost

• Microsoft and LinkedIn, 2024 Work Trend Index (knowledge-worker AI use; share bringing their own tools).
• SHRM, State of AI in HR 2026 (44 percent of CHROs say uneven access to AI tools raises attrition risk, with early-career staff most affected).
• "Uber burned through its entire 2026 AI budget in four months," Fortune, May 2026 (Claude Code rolled out to about 5,000 engineers in December 2025; $500 to $2,000 per engineer per month; COO Andrew Macdonald and CTO Praveen Neppalli Naga questioning the return).
• California Labor Code section 2802 on reimbursement of necessary business expenses, as applied to cell phones and home internet.

Measuring AI's productivity effect

• Brynjolfsson, Li, and Raymond, "Generative AI at Work," NBER, 2023 (customer-support randomized rollout: about 14 percent more issues resolved per hour on average, 30 to 35 percent for less experienced agents).
• Peng et al., GitHub Copilot developer experiment, 2023 (treated group about 56 percent faster on a defined coding task).
• Noy and Zhang, Science, 2023 (professional writing tasks completed faster at higher rated quality).
• METR randomized controlled trial, 2025 (experienced open-source developers took longer with AI tools on familiar codebases).

Written with AI assistance, consistent with this blog's disclosure norm.

Editor's note: the named figures and dates were verified as of June 2026, including Cursor's June 2025 repricing, Copilot's move to usage-based credit pricing on June 1, 2026, Anthropic's weekly caps from August 28, 2025, the DeepSeek bans, the SHRM 2026 attrition figure, the Uber budget reporting (Fortune, May 2026), and the productivity studies (Brynjolfsson/Li/Raymond, Peng et al., Noy/Zhang, METR 2025). Pricing and the still-proposed No Adversarial AI Act are time-sensitive and worth a re-check at publish. The California 2802 point is framed as "may apply," since its application to AI tools is by analogy from phone and internet case law rather than settled AI-specific precedent.