What coding with AI really costs (and how to pay less)

TLDR: The cost of coding with AI runs from zero to hundreds a month depending on the pattern, and most people overpay for not knowing the map. The keys: the three economic models (subscription with quota, pay-per-consumption, free with limits), the ladder starting at Gemini CLI or OpenCode without paying, and the two-agent strategy, the leader for the difficult and the free one for volume, which optimizes most real cases.

This guide is for anyone wanting to adopt agents without signing blank checks, and for anyone already paying who suspects they could pay less. The tool’s price is the visible part: the real cost depends on the usage pattern, and that one is manageable.

1. Understand what you pay: subscription, consumption or nothing

The category charges three ways, and each rewards a different pattern.

The subscription with quota (the $17-20 of Claude Code via Claude Pro, Codex via ChatGPT, Cursor): fixed, predictable cost, with the nuance that the usage quota is the real limit, and intensive use pushes toward the $100-plus tiers.

Pay-per-consumption (the open tools with your key like Aider or Cline, and products like Amp): you pay exactly what you use, unbeatable on irregular use and transparent to the cent, with the trade-off of a variable bill demanding vigilance. On that route the spend is set not by the client but by the model you plug into it, and that is the lever almost nobody pulls: GLM (from $18 a month, with open weights if you would rather serve it on your own infrastructure) fits most clients in the category and performs close to the closed models for considerably less a month.

2. Start free and climb with data

The most common economic mistake is starting at the top: a frontier subscription from day one, without yet knowing your pattern. The sensible ladder inverts the order.

The two weeks on the first rung teach what no comparison site knows about you: how many tasks you delegate, of what size and with how much ambiguity.

The figure justifying the climb is yours: hours saved against monthly cost, measured on your real week.

3. Build the two-agent strategy

The pattern optimizing most real cases is not one agent: it is two. The paid leader (Claude Code or Codex, usually whichever subscription you already hold) for tasks where judgment matters: the ambiguous, the long, whatever touches delicate zones. And the free or cheap one (Gemini CLI, OpenCode, or an open client with GLM behind it) for mechanical volume: the scripts, the bounded tasks, the automations that run alone.

The economic logic is simple: the leader charges by quota, and spending it on tasks the free one solves equally is throwing quota away. The division of labor keeps the subscription for what justifies it and the volume where it costs nothing.

In practice, keeping two agents configured takes ten minutes, and per-task assignment becomes habit within the first week.

4. Watch the patterns that blow up the bill

The category’s surprise bills come from known patterns, and knowing them is avoiding them.

Runaway context: very long sessions and projects without an instructions file make the agent reread and re-explore, burning quota or tokens on orientation. Bounded sessions and prepared context are direct savings. Vague iterations: every “no, not like that” is a paid execution, and the precise first-time request is the cheapest optimization there is. Unmeasured parallelism: three agents spend like three, concentrated into fewer hours, as the parallel agents guide develops. And in builders and credit-based tools, the pecking of minor adjustments that drains the pool without advancing the project.

The universal control tool: looking at the consumption panel once a week for the first two months. Your own pattern, once seen, manages itself. The whole sector lives in AI for software development.

Common mistakes

Paying for the intensive plan just in case. The standard quota covers more than fear suggests, and the high plan takes five minutes to buy the day it is genuinely needed.

Spending the leader’s quota on mechanical tasks. It is the silent waste the two-agent strategy eliminates without losing capability.

Ignoring your own pattern. Without looking at real consumption, plan decisions are faith. Two months of observation turn the bill into a choice.

Optimizing the cent and losing the hour. The opposite extreme fails too: wrestling a free agent for a whole afternoon on a task the leader solved in twenty minutes is the classic false economy.

Frequently asked questions

What does a typical developer spend per month?

The common patterns: zero on the free route well used, $17-20 with one leader subscription, and $40 upward combining a high subscription or intensive consumption. The two-agent strategy keeps most people in the middle band with capacity to spare.

Is the free route genuinely enough?

For personal use, bounded tasks and automation, yes, comfortably. The paid jump is justified by the ambiguous and the long, not by volume.

Subscription or pay-per-consumption?

Regular daily use, subscription: the fixed fee wins and removes accounting. Irregular or directed use, consumption: you pay exactly what happened. The doubt resolves by looking at your real week, not the theoretical one.

Do parallel agents multiply the cost?

They spend the same as serial, concentrated: the same quota drains in fewer hours. The practical effect is that intensive parallelism brings the high-plan jump forward, worth knowing before you get fond of it.