Cheap, unlimited AI is ending. The next skill is orchestration

Not long ago, burning through your AI subscription quota was nearly impossible: with OpenAI, a while back, it simply didn't happen. Today I pay $100 and $200 monthly subscriptions and I hit rate limits week in, week out. And it doesn't take super-intensive usage to get there.

It's not an accident. Several things are converging: the new models cost far more to serve, compute has become the bottleneck, the labs need profits now that they're eyeing IPOs, and the models themselves, being more capable, work for longer and burn more tokens per task. Everything pushes in the same direction: the limits arrive sooner.

And that change in how we consume AI asks for a new skill that almost nobody is practicing yet.

We're not paying for answers anymore. We're paying for work

A couple of years ago, using a model looked like this:

Question → answer.

Now, when I ask an agent to implement a feature, what actually happens looks more like this:

Goal → plan → read files → execute → fail → fix → more tools → verify → result.

A year ago, an agent task that ran for 20 minutes felt outrageous. Today I launch loops that run for hours: I define a goal and the agent chases it relentlessly, planning, failing, correcting itself and verifying until it's done. And to be clear, that's not a complaint: if I want real output, the model needs time and steps.

But there's a direct consequence: the unit of consumption is no longer "a conversation". It's a work session. And a work session burns far more compute than a question.

And the trend keeps going: every new generation of models thinks for longer, turns things over more, and does more on its own. More consumption, yes. But the output is usually much richer too.

Subscriptions were hiding the real cost

For a while now, the $20, $100, $200 per month subscriptions have been subsidizing usage whose real API cost was much higher. Companies absorbed the difference to win users and build habits.

That era is ending, and it's pure arithmetic: frontier models are expensive to serve, agentic usage burns a lot, and unlimited plans don't survive users who run long work sessions every day. In fact, the market is already moving to "included quota + pay per use". And I wouldn't rule out the next step: models you can only use paying per use, outside any subscription.

And here's what's really on my mind: top-tier intelligence is becoming a resource you pay for by consumption, like electricity. Big companies will pay for it without blinking. The question is what happens to the freelancer, the indie hacker, the small team, when using the best costs what it really costs.

I don't think access disappears. But the gap between occasional use and intensive use could change a lot. And that gap is productivity.

The answer is not paying more

Here's the part that I think matters most: not every task needs a frontier model.

A lot of what I ask the most expensive model today could be done by a small model, a local one, a cheap API one... or honestly, a script. Tests, linters, deterministic tools, well-built pipelines. Not glamorous. Works.

The question stops being "which model is best?" and becomes "what does this specific task need?". That turns the price worry into a strategy.

The worse the model, the better the system has to be

I keep coming back to one idea that sums all of this up:

When the raw intelligence of the model goes down, the importance of the system around it goes up.

With a frontier model you can ask for something vague and probably get something decent. With a small model, nop: you need better context, better instructions, examples, tests that verify the output, clear limits, a way to escalate to a bigger model when needed.

I call that layer around the model, still a bit fuzzy (I admit), a harness: the templates, the repo context, the tools I let it use, the verification scripts, the reusable prompts, the rules for when to use which model. A good harness multiplies the value of cheap models and reduces the dependency on expensive ones.

That's why local models went, at least for me, from curiosity to something more serious: they won't replace frontier, but they can absorb a big chunk of the repeatable, verifiable work. That's operational independence.

The skill that's coming

If I had to bet (fair warning: my AI predictions have a mediocre track record) I'd say the next valuable skill is not prompting, not even "using agents". It's orchestration: knowing how to break work down, give each task just enough model, put verification where it matters, and spend the expensive model only where it actually makes a difference.

In fact, this already has a name out there: harness engineering. First came prompt engineering, then context engineering, and now it's about designing the whole harness: the system that wraps the model and decides what it sees, what it can do, and how its output gets verified.

I can't control the price of frontier models. What I can control is how I design my workflows to depend less on them. That's what I'm doing right now: learning to build my own working layer with AI, getting it wrong fairly often, and writing it down here.

If you take one sentence with you, take this one:

The next gap won't be between people who have access to AI and people who don't. It will be between people who know how to orchestrate it and people who only know how to consume it.

I don't know if it arrives in one year, two, or five. But just in case, I'm already practicing.