Do We Still Need Professionals?
The value was never the production. It was the judgement.
Word on the street is that AI can now do most knowledge work — some of it better than humans. So the question every business is quietly asking is reasonable: why pay a professional salary — or a professional invoice — when a $20 subscription will do? Here is the uncomfortable part: the $20 is not real, and neither is the “do”.
Copywriting
Large Language Models were built for language and text. Surely they can generate whatever copy I need. If I got a dollar back from my AI providers every time I had to give the model feedback, they would go bankrupt. When the AI misunderstands or hallucinates, that is my problem: I have to review the output, which means I have to know what good looks like, and I have to spend the time. Keep that sentence in mind — we will keep coming back to it.
Coding
Ask an AI to generate a demo and it will generate a very impressive demo. Impressive demos are not production code. The moment you try to ship, you discover that programmers were doing rather more than turning requirements into text — and that someone still has to do those things. Not least because half the job was never executing the requirement: it was extracting the actual requirement from the stated one. An AI will implement what you asked for — as long as the problem you gave it was well specified and the model had all the knowledge it needed to solve it. What you asked for and what you needed are rarely the same document.
The SaaS apocalypse that wasn’t
We were told there would be an AI revolution and the SaaS companies would be the first against the wall — why pay $20 a month for invoicing software when you can generate your own? And it is true: building your own invoicing system has never been easier. So far, approximately nobody has done it, because spending hundreds of hours to save $20 a month is still a terrible trade. And the build is the cheap part. Now you own an invoicing system: the maintenance, the edge cases, the VAT rule that changes in January. The $20 was never buying software. It was buying a vendor whose job is to care about invoicing so that you don’t have to — someone else’s judgement and responsibility, on subscription. Making production cheaper did not change that arithmetic at all.
Responsibility
If something goes wrong, who do you sue? The model provider will point you to the terms you signed, where it says the responsibility is yours. In the regulated professions this is not rhetorical but statutory: an audit needs an auditor’s signature, a filing needs a lawyer’s, a prescription a doctor’s — the law does not recognise “the model said so”. Software engineers carry the same burden without the statute: no regulator demands a signature on a deployment, but when the payments system goes down at 2 a.m., “the AI wrote it” is not an incident response. A professional carries insurance, a reputation, and a signature. A subscription carries a disclaimer.
Cost
The $20 subscription is not a price. It is a promotion.
We can put a number on it, and it does not have to be hypothetical. I am taking Claude as the example because it is the most popular and most highly regarded of the coding agents, and its tooling bills your tokens at the vendor’s published API rates — so every session comes with a receipt. Mine, for July: $7,567.60 of API-equivalent usage on a $200 subscription — a 38x multiple. And that is side-project usage: a couple of hours on weekday evenings, more on weekends, around a full-time job. Even a quiet month runs multiples of the fee — June closed at $1,836.35, nine times what I pay. My most expensive single day cost $784.85 at list price: nearly four monthly subscriptions in one day. A full-time practitioner with ample work would not stop there. Do the multiplication yourself.
You may object that I only consume like this because the rate is flat, and that a live meter would make me careful. Correct — and note what “careful” consists of: knowing what to ask for, when to stop, and which dead ends not to fund. The meter does not delete the bill. It converts it into a demand for judgement, and we will come back to what that costs.
Where does the money actually go? Not into what I type, and not into the answers I get back. It goes into re-reading. An agentic tool works in loops: at every step it re-reads the code, the plan, and everything it has produced so far — the way a contractor re-reads the blueprints before every cut. Over seven months of my logs, that re-reading was 95% of all tokens: 8.4 billion out of 8.8 billion. The billing line calls it “cache reads”; you will not find it on the friendly dashboards, only on the meter.
And even the quiet months are a lower bound on the distortion, because the calculation assumes the API prices themselves reflect costs — a generous assumption for model vendors that have yet to produce a profitable year. Nobody outside these companies knows whether list price covers even the electricity. It certainly says nothing about the training runs, amortised over models that are obsolete within eighteen months, or the hardware underneath: GPUs depreciated over five or six years in an industry that replaces them in three. Stretch the depreciation schedule and the losses shrink on paper without a single token getting cheaper. That is a question for the auditors.
You do not have to speculate about when the subsidy ends, because the repricing has already started. In April, GitHub announced that Copilot plans move to usage-based billing from 1 June: a monthly allowance of AI credits metered at API list rates, with overage billed on top. Their stated reason, in their own words: “the current premium request model is no longer sustainable”. Base prices did not change and plain code completions stay included — what changed is that the generous part became an allowance, one GitHub explicitly reserves the right to resize as the economics of AI evolve. Existing Business and Enterprise customers are being eased in with promotional credits through August. The promotion, as promotions do, ends.
Here is why the arithmetic matters. Today you can take a junior developer, hand them a Claude subscription, get mid-level output, and keep paying junior money. That trade only works while the tokens are subsidised. A developer running agentic tools eight hours a day is not, at list prices, a $200 line item — they are a five-figure monthly compute cost, a second salary hiding in a subscription. When the meter reflects usage, junior-plus-subscription does not get slightly more expensive. The trade inverts — and you are back to asking what you are actually paying for, which was never the typing.
There is a dependency problem hiding in that trade too. A professional you hired cannot have their capabilities silently downgraded overnight. Your AI workflow rests on a vendor who can change models, limits and prices at will — and does. GitHub demonstrated it in June. Anthropic demonstrated it all summer. Its frontier Fable 5 model launched into subscriptions on 9 June, was pulled under a US export-control directive, and came back. Subscribers were then told it would leave their plans, with the deadline extended twice in twelve days — the second extension landing three days after OpenAI shipped a comparable model at half Fable’s input price. The final settlement, in effect from 20 July, was decided by tier: Max and premium Team seats keep Fable permanently, capped at half of their existing weekly allowance; Pro and standard seats got a meter, with a one-time credit for some. Anthropic’s stated reason throughout was capacity and unpredictable demand; the widely held reading is that what settled subscribers’ access was a competitor’s price list rather than anything in their contract.
Either way, the teams budgeting around the model learned which side of the line they were on three days before the cliff. If your delivery capacity is a line item in someone else’s pricing experiment, you do not have a capability. You have a lease.
Two footnotes for the pedants. API list price is the vendor’s price, not their cost, so these figures are “API-equivalent value”, not “what I cost Anthropic”. And the multiples are computed after granting every advertised discount — the billions of cached tokens above are priced at a tenth of the fresh-input rate.
Where do the seniors come from?
The junior-plus-subscription trade has a second act nobody prices in. If juniors spend their formative years supervising AI output instead of doing the work badly and slowly themselves, where does the next generation of seniors come from?
The standard reply is that we have heard this before — compilers, IDEs, Stack Overflow, frameworks — and the pipeline survived every time. But those abstractions removed production steps and left the feedback loop intact: you still wrote the logic, shipped it, and got punished by reality when it was wrong.
Notice, too, what kind of teacher the old tools were. A compiler is deterministic: give it the same broken input a hundred times and it returns the same error a hundred times, until you understand. A coding agent is probabilistic: retry the same prompt and it might simply fix the thing. A senior uses it like a compiler — specify, constrain, verify. A junior, through no fault of their own, learns to use it like a slot machine, because the slot machine occasionally pays out — and intermittent reward is the strongest habit-builder there is.
The compiler forced comprehension. The agent rewards persistence at the lever.
At the end of it, the junior has learned nothing — except that pulling again sometimes works, and every pull is on the meter.
Judgement — knowing what good looks like — is not downloaded; it is accumulated through years of being wrong with consequences. The industry is currently arbitraging away exactly the apprenticeship that produces the people this article says are the product. That is not a moral complaint; it is a supply forecast. We will come back to what it does to the price.
“But the models keep getting better”
They do. Note, however, what happens at the frontier: capability and price climb together. Anthropic’s most capable widely released model, Fable 5, costs twice per token what its Opus tier does, and after two months of access chaos it settled by plan: a standard feature on Max and premium Team seats, capped at half of the weekly allowance, while the $20 plan runs it on a meter. The best model is never the one in the $20 plan; the $20 plan gets last year’s best. It is true that competition cuts the other way — the timing of OpenAI’s cheaper Sol release is widely credited with keeping Fable inside subscriptions at all, and a price war can keep the promotion running longer than the accountants would like. But a subsidy sustained by two loss-making rivals trying to outlast each other is not a pricing floor; it is a game of chicken, and your budget is riding in one of the cars. And even granting free, perfect models: better production does not shrink the review burden, the liability, or the question of who signs. It makes the cheap part cheaper.
So how many do we need?
The honest concession first: fewer people will be producing. If your objection to everything above is “fine, so we need professionals — just fewer of them”, you are partly right, and this article is not going to pretend otherwise.
But look at what happens to the ones who remain. Everything the AI produces needs reviewing, so demand for judgement goes up. The junior pipeline that manufactures judgement is being switched off, so supply goes down.
And there is a third force people miss: judgement now controls the AI bill itself. Someone who can specify a task precisely, steer the model, and recognise a dead end burns a fraction of the tokens of someone begging the AI through fifteen retries to do the right thing. Bad judgement pays twice — once in the rework, once on the meter — and it does not even feel bad while it happens: people working outside their depth with an AI feel enormously productive while the time burns, through review cycles, rework, and confident wrong answers accepted and unwound a week later. Feeling fast and being fast are different measurements, and only one of them appears on the invoice. Today the subsidy hides the second payment; when usage-based pricing arrives, it stops hiding.
Fewer professionals, then — but the ones you keep become the most expensive and most contested resource in the building. That is not a comfortable answer for anyone’s headcount plan.
A disclosure
You may object that a consultancy selling senior professionals would say all of this. Correct. You should also know that we ran the experiment on ourselves: Avant Media has spent the past year automating everything we could reach — the plan, loosely, was to run the firm from a beach. I am writing this from the office, which is unfortunately still not on the beach — it is in London. The production automated beautifully. The judgement did not, and it turns out the judgement was the job. The receipts are above; the arithmetic doesn’t care who did it.
So, do we?
The value was never the production. It was the judgement. AI has made production nearly free and judgement more expensive, because now everything needs reviewing — every paragraph, every pull request, every confident answer.
Professionals are the people you pay to know what good looks like. The subscription does not come with one.