I still run into people who work like this: a browser tab with a chat window open, ask a question, copy the code, paste it into the editor, move on. No agents, no project context, nothing. Many of them also use AI the way you'd use Google: they take the first answer and assume it can't be wrong. And it can. It invents functions, gets basic assumptions wrong, and tells you all of it with staggering confidence.
Every time I see this I think the same thing: there's a ladder here, and some people aren't even on the first rung. So today I'm going to lay that ladder out. The levels I see of working with AI agents to write code, what each one costs, and where I've landed after trying almost all of them.
The usual disclaimer before we start: this is my opinion and my experience doing full stack development with Drupal. AI for writing or translation is a different story, and it deserves its own article.
Level -1: AI as a search engine
That way of working I described at the top is what I call level minus one. I won't even give it a zero, because it doesn't make the classification. You can't call it working with agents; it's chatting with a website.
A few years ago that was all there was, and you had no other option. Today it's being out of the game. If you recognize yourself here, the first step is simple: install Claude Code or OpenCode and let the tool work on the code directly, with the project context in front of it, instead of shuttling snippets through the clipboard. That change alone puts you in a different league.
Level 1: plain old vibe coding
The first real level belongs to whoever already uses agents, but with everything on defaults. No specialized agents, no skills, nothing configured. Opus or Fable for everything, including renaming a variable. And without being able to read the code that comes out, so there's no review at all: if it seems to work, ship it.
I've already written about the trap this turns into, so I won't repeat myself here. What interests me now is the economics, which gets discussed far less: it's the most expensive way to work there is. You're paying for the priciest model in the catalog for tasks Haiku handles just as well, you're burning tokens with no control because nothing is optimized, and on top of that nobody validates the result. You're throwing money away at both ends.
Level 2: you think, the AI codes, you review
Now we're talking about a developer who uses AI properly. They have an agent system set up, and each agent has the right model assigned: Haiku for mechanical stuff, Sonnet for everyday work, Opus for what genuinely requires judgment. If you run OpenCode with open-weight models, same idea with DeepSeek, Qwen, or whichever fits you best.
The division of labor changes. You plan the task and document the requirements. The AI does the heavy lifting. And then you review what it generated before anything reaches production. You spend more time than before planning and reviewing, yes, but far less total time per task, because the heavy part is no longer yours.
If you want to see this foundation actually set up, mine is public. In ddev-ai-workspace you have the full environment I work with, DDEV with Claude Code and OpenCode in separate containers inside the same project, and in drupal-ai-agents you'll find the specialized Drupal agents with their skills and the model assigned to each one. I've written on the blog about how I use it day to day, so if you work with Drupal and DDEV you have somewhere to start without building everything from scratch.
The catch at this level is obvious: the bottleneck is you. Everything passes through your eyes, before and after. No matter how many agents you have running, your review capacity sets the pace.
Level 3: the meta-harness
Before climbing another rung, a quick definition. I call a harness whatever runs the models and lets them work on tasks autonomously: Claude Code, OpenCode, Codex. A meta-harness is the layer above, a tool to control the harnesses among themselves: making them talk to each other, having one validate when another finishes, triggering tasks automatically. In short, orchestrating the whole thing once you no longer have one agent working, but several.
It makes complete sense when you run several projects and each one has its own harness. I built my own: it tracks my hours, my token costs and my tasks, and from the tasks it automatically spins up git worktrees across the different projects. That way, within a single project I can be on several tasks at once, each running in its own separate worktree without stepping on the others. If you write code for a living, you know what I'm talking about.
At this level, the review is still yours, same as level 2. What changes is the scale: you go from handling one task to handling several in parallel without losing control, and with hours and costs tracked per task on top of it.
Level 4: the AI reviews before you do
The fourth level is where the meta-harness starts doing real work: when one harness finishes, it triggers validation with a different one. One model makes the changes in Claude Code, another reviews them from OpenCode or Codex and, if it finds something wrong, sends it back to the first one to fix. And so on, in a loop, until the code comes out clean the other side.
Some people claim that with this you no longer need to review or even understand the code, that all it takes is someone who sets the system up well and from there it's magic, straight to production. I've tried it and I don't buy it; I'll get to that in a moment. But one thing is true: the quality of what reaches you improves a lot.
The important nuance: you still end up reading all the code, you don't review less. What changes is how many times it passes through you. At levels 2 and 3, everything you caught went back to the AI, you waited for the fix, then reviewed again, and every one of those iterations had a human as the bottleneck. Here, those back-and-forths are absorbed by the agents among themselves, and only the near-final version reaches you. You review the same lines, but far fewer times, and the time you spend on review drops off a cliff.
The problem is the bill. You pour a lot of money into tokens for validations a human would often have settled in five minutes. You work faster because the human bottleneck narrows, but you pay for it.
Level 5: nobody reviews anything anymore
And the last rung: same as level 4, but with no human at the end. You trust that the AI's review is good enough, and it ships to production as is.
I've tried it with Drupal and my conclusion is no. The review signs off on things that are wrong, makes incorrect assumptions and doesn't even notice. For a small, cheap website, the kind where if something breaks you fix it whenever you can, it might make sense. For a large project where performance and security actually matter, no way. As of today you can't fully trust a review done by another AI, and it depends heavily on the kind of work. Human review is still non-negotiable, so level 5 is one I rule out entirely.
Seen through a company's eyes, the ladder looks like this: level 1 people are bad workers, because they neither review nor understand what the AI is doing. Levels 2 and 3 are the normal ones, the people doing their job well with today's tools, level 3 with more organizational muscle. And levels 4 and 5 are the most advanced, but they come with an extra cost somebody has to justify.
I've gone back to level 3
I tried level 4. I flirted with level 5. And I've gone back to 3, basically because of cost.
The meta-harness, as I said above, is already built and it's my daily driver. From there I take one step toward level 4 only on certain tasks: I have them self-review before they reach me, so I don't have to go over the same code as many times. It costs me more money, but it saves me time. And that's the balance I'm working within, because doing it for every task makes no sense to me: it's just burning tokens.
I don't consider it settled, though. I have an idea for how to take that step toward level 4 without the bill exploding, but I'll get to that a bit further down.
So why don't you run everything locally?
Here comes the question I get all the time. I have a server at home with an RTX PRO 6000 with 96 GB of VRAM, serving models through vLLM. It wasn't cheap, though I caught it on sale and, all things considered, it worked out well. And even with that hardware, I still turn to external models for the serious work. Why?
Because the quality of local models isn't there yet. These past weeks I've been testing the Qwen3.8 that came out a few days ago, and it performs noticeably better than the previous version, at least on my setup. But Opus is still above it, and Fable even more so. More expensive and in a third party's hands, but better.
Not that the paid ones are anything to write home about either. They generate code that seems to work, but with poorly optimized pieces, decisions that don't fit the project, or closed-off solutions that leave no room for what you'll need six months from now. In Drupal I see it constantly: they want to fix everything with custom code, when half the time it was configuration, or a contributed module that's been on drupal.org doing exactly that for years. I've also run into custom patches proposed for a problem that wasn't in the module at all, but in a misconfigured setting. They hallucinate, in the most literal sense. And those things won't be caught by another AI, no matter how many review loops you stack. They're caught by someone who knows the ecosystem.
Full transparency: right now I'm not paying Anthropic. They gave me a few months of Claude Code subscription for free for contributing to open source projects, the equivalent of the 200-euro plan without paying a cent. But free doesn't mean unlimited. It works like the regular subscription, with its usage window, and that window runs out. When I was working at level 4 or 5, the review loops between agents drained it far faster, and I'd run out of quota for the tasks that actually mattered to me.
That's when something clicked. I'd rather stay on top of the AI and steer the task where I want from the start than leave it on its own and fall into the usual cycle: it does the task, I review it, it's wrong, I tell it to redo it, I review again, it's improved but things are still wrong, it redoes half of it again... and you burn tokens for nothing. Level 4 was eating into my subscription, which luckily I don't pay for. And when I was using open source models through third-party APIs, which I did pay for, the bill climbed quite a bit higher than I expected. That's why I've mostly shelved levels 4 and 5.
Those external APIs for open source models, in fact, I've dropped entirely: quality-wise they're worse than Fable or Opus, and with Qwen3.8 on my own machine I get very similar results without depending on anyone or paying per token. So my ecosystem today is Qwen3.8 running on my server, which I still have to amortize, plus the free Claude Code subscription. A sweet deal, yes, but one with an expiry date, which is why every calculation in this article assumes I'm paying for every token.
The next thing I want to try is a different split: have Qwen handle all the initial code editing locally, and save the Anthropic subscription just for level 4, for the review loops. If the usage window stops draining so fast, I can play with both and get more work done at the same cost or less. Or at the very least get it done faster, with me being less of a bottleneck than I am now. When I have real data, I'll write about it.
If you want to optimize costs, I'd start here
With all that said, if your company wants to cut its AI bill, this is the order I'd follow.
The first step is free and it's the one most people skip: set up your agent system properly and assign models, so Fable isn't doing what Haiku can handle. That alone brings token spend way down. I covered how I have it set up in the article on optimizing token usage in Claude Code.
The second step is building your local inference server, which is where I see the real payoff: you save on external API calls and stop depending on third parties, something I've already written about at length. Hardware-wise there are two families. GPU servers, or unified memory, meaning the Spark machines that have become popular or a Mac Studio. Unified memory gives you more memory for less money, so it's more cost-effective for loading large models. In exchange, it runs considerably slower.
I went with a GPU for the speed, and I don't regret it. I load models of 30, 40 or 50 GB and dedicate the rest of the VRAM to context windows and concurrent requests: over 200,000 tokens of context, above 100 tokens per second, and between 6 and 7 requests at a time depending on the model. And that speed lets me turn on thinking locally: the model spends a while mulling over its answer before responding, burns quite a few more tokens, but since they're mine I don't pay for them, and the code comes out clearly better.
Sizing this properly is a science of its own. I got as far as testing configurations with up to 20 concurrent requests, which is genuinely welcome when you have several agents running in parallel, but they required a far more quantized model, meaning more compressed and therefore dumber. And a dumb model is no use to me no matter how many simultaneous requests it allows. In the end what I'm after is the balance between three variables: quantization, context window and concurrency. A model smart enough, fast enough, and with headroom to run several projects at once. That sweet spot depends on each model, and since a new one comes out every few weeks, I end up retuning the setup regularly. That's why until recently I combined it with external APIs for much larger models, the kind that don't fit on my card. This is in constant evolution.
On money: the minimum per worker for something decent sits between 3,000 and 4,000 euros. A machine like mine today starts at around 15,000, roughly double what it cost me with the sale. Unified memory stays in the 3,000 to 5,000 range, with more memory than mine but much slower.
Which one to pick? It depends on where your bottleneck is. If your workers have spare capacity and the AI is what's holding things up, go GPU: more tasks in parallel, and faster. But if the AI already finishes tasks before anyone can review them, the extra speed buys you nothing, and a slower unified-memory machine with more memory might suit you better: while one task runs, the worker reviews the previous one.
Either way, it's a one-time cost. In under a year you amortize it against what goes out in tokens and third-party subscriptions. And as a bonus, you stop worrying about whether prices go up or limits get tightened tomorrow. And they will.
One last note for those staying on external APIs, something I already mentioned when I explained my OpenCode setup: set up an AI proxy at the company level, for example with LiteLLM. The idea is simple. In the proxy you configure which models are available and define aliases, along the lines of smart model, standard model, cheap model, and you give your workers access to the aliases, not the models directly. If tomorrow a new model comes out that's just as capable but cheaper, you change the alias configuration and the whole company switches to the new model at once, without depending on each worker implementing it correctly on their machine or using the models they're supposed to.
With the proxy you also gain the control almost every company is missing: you know how much is being spent, which workers use AI more or less, and which models each one is using. And you can set per-worker limits, so whoever hits theirs gets cut off from the expensive models and has to carry on with the cheap ones. For deciding which models the company gives its people and what that costs, I don't know a better way today.
Which rung to stand on
If you're asking me to pick: work at level 2 and, as soon as you're juggling more than one project or more than one task at a time, build the meta-harness and climb to level 3. That rung doesn't burn extra tokens, and it pays for itself in the order it brings. Level 4 is tempting, and if money isn't an issue at your company, go for it: you work faster and lose far less time on reviews. But for what it costs versus what it delivers, the numbers don't work out for me today. And level 5, rule it out entirely.