Stepping Off the Coding-Plan Treadmill: Everything I Build Now Costs $60 a Month

There’s a treadmill nearly every serious user of AI coding tools ends up on, and nobody talks about the top of it.

It starts innocently. You sign up for a coding plan — Devin, Claude, Codex, Cursor, take your pick. You bring your methodologies, your skills, your frameworks, all set for the next genius project. Then you get into the thick of it and back up against your plan limit. You wait for the reset to fire, continue, and hit it again. So you step up to the $100 plan, and for a single project life is good — the limits stop biting. But now you can see the capacity you’re paying for, so you start running projects in parallel, and boom: limits again. You’ve tasted what that level of throughput feels like, and you’re not giving it back. So you make the plunge. Top tier. Two hundred–plus a month. All seems right with the world, apart from the small matter of burning $200+ a month on a coding plan.

Then the top rung reveals its own problem. You go on vacation. A work project starts eating your off-hours. You’re under the weather, or the World Cup is on. That great $200 plan sits there unused more than it should — but you won’t downgrade, because you hate waiting and you refuse to give up the gas to build as many whatevers as you see fit.

If any of that sounds familiar, here is the alternative: the best possible products, built with top models, no plan limits — for $60 a month.

The short version, for the impatient

Skip the reasoning if you like. The setup is three $20 subscriptions: the Codex plan, the Anthropic plan, and the Devin plan. Specs and plans are authored on Opus 4.8 through the Claude CLI using the Superpowers framework, cross-reviewed by Codex, and all coding is delivered by Devin’s SWE-1.7 — a model Devin includes at no additional cost. The sections below explain why the economics hold.

The organizing insight is simple: the phases of a project that demand the most intelligence consume the fewest tokens, and the phase that consumes the most tokens doesn’t need your most expensive model.

Phase one: expensive thinking, cheap tokens

The spec is where the meat of the project lives and where the highest level of intelligence gets applied — and, ironically, it barely costs anything in tokens. That irony is the foundation of the whole approach.

I author specs with the Superpowers framework’s brainstorming skill, running Opus 4.8 in the Claude CLI. The process is conversational: the model asks a question, you answer it, the model thinks about how that answer should be articulated in the spec, and the exchange repeats until it builds the document. You can get an enormous amount of this back-and-forth engagement out of a $20 plan, because none of it moves a bunch of tokens.

A spec you haven’t reviewed is a liability, so the draft goes through a cross-model review cycle:

A few judgments worth passing along. Codex doesn’t need a skill for this work — its models are really good at spec review from a simple prompt, writing their findings to a review.md. That file goes back to Opus, which decides whether each point actually applies before touching the spec; you’re triaging the review, not obeying it. Then the Claude side takes a turn — with Superpowers installed it runs its own spec review and will most likely find gaps the first pass missed.

You could run these loops until the end of time, because every pass is a fresh look at a changed document. I usually do one more and stop; whatever’s still missing tends to emerge in development anyway. How many loops is your call. What is not negotiable, in my process, is that the spec and the implementation plan end up rock solid — that’s precisely why the strongest models are assigned to this phase, and because the work is token-light and spread across two harnesses, the $20 plans rarely feel tight here.

Phase two: a plan built for many hands

With the spec locked, the Superpowers plan-development skill builds the implementation plan. Before it starts, I give the model three pieces of guidance: agents will deliver this plan working in git worktrees; the plan must be organized into a series of batches that won’t clobber each other when delivered in parallel; and those batches must be grouped into reasonable PR boundaries — batches 1 through 3 make up PR 1, and so on.

That guidance does double duty. It doesn’t just structure the plan for parallel delivery — it forces the model to think much more deeply about what is actually being delivered and how each spec requirement gets realized, far beyond whatever default the plan skill would produce on its own. And if you have a team of coders with their own harnesses, or you genuinely intend to build with a fleet of parallel agents, this is what limits the pain when the coding starts.

The review dance repeats from phase one, with one change: Codex gets the spec and the plan, not the plan alone. Same pattern otherwise — raw prompt, review.md out, Opus triages and applies what’s appropriate. I highly recommend a second loop here; every time the plan changes, the reviewer sees it fresh and finds new concerns. But mind the same stopping condition: at some point the model is down to nitpicks, and nitpicks are an expensive thing to have a model like gpt-5.6-sol teasing out.

Phase three: where the magic happens

Everything so far has been setup for this, and this part requires Devin.

Because the plan was built for parallel delivery, the batches are on the smaller side — and small, well-specified batches don’t require a super-powerful model to code. Devin has exactly the right model for it. SWE-1.7 is an unbelievable coder, it is blazing fast — genuinely, try to find something faster — and Devin gives it away free on the plan. Multiple sessions, agent fleets, whatever you want to run.

This phase is where the tokens actually burn. Run it through Sonnet or Codex and you’d tear through those coding plans at breakneck speed. Run it through SWE-1.7 and the most expensive phase of your project becomes the cheapest. Devin now has a CLI, so you never leave the terminal — and as a bonus, the plan includes other models, like GLM and Kimi, for whatever you’d use them for.

The Devin harness deserves the same care as the others. Your standards live in an AGENTS.md; the skills you want SWE-1.7 building with — worktree development, TDD, whatever else it needs beyond the spec and plan — are installed; and how you want reviews conducted, and with what, is spelled out. My own workflow stops after each completed batch and calls out to Codex for a code review, looping until diminishing returns — generally light calls, given how the work is organized. Once the batches that make up a PR are done, one more review cycle over the whole set makes sure nothing has been missed.

And if a review ever does exhaust a Codex or Claude limit, there’s a release valve:

Why not just run everything through Devin?

Fair question. If SWE-1.7 is this central to the whole approach — and the Devin plan carries other models besides — why keep three subscriptions at all?

Because the arrangement only works when the free thing stays free. SWE-1.7 costs nothing for the coding, and the coding is all Devin is being asked to do. Try to pile spec development, plan development, and all of those review loops onto the same $20 Devin plan and you will absolutely chew past it. Each workload is affordable precisely because it lands on a subscription with nothing else to carry: authoring on the Anthropic plan, reviews on the Codex plan, code on the Devin plan.

Collapse everything into one plan and you’re back on the treadmill, just with a different logo on it.

What I’m deliberately leaving out

I won’t be going into the PR review cycle itself. Most professionals have a reviewer wired into the PR — CodeRabbit or Greptile, or something homebuilt like Hermes — and there are a lot of biases and preferences about how that process should work and integrate with GitHub. That’s a different conversation.

The bottom line

A rock-solid spec, authored and refereed by the strongest models available. A plan organized into small batches that welcome parallel delivery. And the token-heavy work — the actual coding — routed to a genuinely excellent model that costs nothing beyond a $20 plan.

That’s the whole trick. You can literally build anything for $60 a month without backing up against coding plan limits — for exactly as long as Devin keeps giving SWE away.