Blog
Stop Using Your Most Expensive AI Model to Stamp the Paperwork
I use AI coding tools every day, among them Claude Code, OpenCode, Cursor and Copilot. At some point I caught myself saving my prompts for “real” work. I was asking fewer questions and trying fewer weird ideas. Every prompt went to a premium model, and between token limits, session limits and rate limits, I could feel each one.
When I looked at what I was actually asking for, most of the work was small. I was updating docs, routing a task, scheduling implementation work, or making a change like “move this thing over there and run the test”. For an architecture decision, a security review or a hard production bug, I want the strongest model I can get. For everything else, sending the request to a frontier model was like asking my most senior engineer to staple documents. I had been giving every task the same model and the same budget.
Trying cheaper models
Cheaper and open-weight models had quietly become good. They handle bounded, mechanical work well, like editing a README or making a small change and running the tests. In some cases the cheaper model costs a tenth or even a hundredth as much.
My first attempt was to patch Claude Code to point at a local Ollama server instead of Anthropic’s API. It worked, and I got decent uninterrupted work done, but it felt clanky. That pushed me toward OpenCode, which is model-agnostic. I can connect different providers and switch models without changing my workflow. Once switching was easy, I kept asking why one model was doing all the jobs.
Matching the model to the job
I split the work into three tiers.
| Tier | Used For |
|---|---|
| Cheap and fast | Routing, scheduling, bounded tasks |
| Balanced | Everyday implementation and review |
| Premium | Deep architecture, hard problems, security escalation |
Two more changes kept the cheap tiers cheap. The first was how agents talk to each other. When an agent explains a change to me, I want the full reasoning. When it hands work to another agent, a typical note reads like this:
After carefully analyzing the implementation surface area, I have determined that the backend engineer should inspect the following files and consider the implications of the existing authentication flow…
The same handoff can be:
Need backend fix. Files: X, Y. Run tests: Z. Risk: auth. Do not touch docs.
Every extra word passed between agents costs tokens and adds to the context of the next call. In oowl, I call the short version Caveman-Lite.
The second was context. When one agent does everything, it carries the requirements, file contents, earlier decisions and failed attempts from the whole session into every call. Now each role gets only what its job needs. The planner gets planning context, the engineers get their own files, and the reviewer gets the implementation summary and verification evidence.
Small, safe tasks take a fast path. For bigger work, I approve a design and a plan before anyone writes code, and review is its own phase.
oowl
This all became oowl, the OpenCode Opinionated Workflow Layer. It’s an open-source layer on top of OpenCode where cheap models route and schedule, balanced models build and review, and premium models handle architecture and security escalation.
I don’t think the future of AI development is one chat window where a single model does everything. That makes a good demo, but it’s a weird way to run a team. I put oowl out there because I found it useful.