My $0.40 Receipt After Pairing Cheap First

01 / One evening, two models and a $0.40 receipt line

Last Sunday I spent four hours pairing on a 340-line Python script: it had to read a CSV, merge two tables, and write a summary. I opened one terminal, pointed it at the cheapest model I trusted for ordinary work, and told myself I would escalate only when I was genuinely stuck. Four hours later the receipt line for the whole evening read $0.40. About two thirds of the turns never touched a stronger model at all.

That number is not a benchmark and it is not a promise about your account. It is simply what one real evening cost me, and the reason I want to show you the habit behind it. Most beginners open an expensive model and leave it open. The meter then charges premium rates for every typo, every naming question, and every format fix. A cheap model handles those turns at a fraction of the cost, and the stronger model is kept in reserve for the moments where its reasoning actually pays for itself.

The pattern is simple enough to copy tonight: cheap model first, a written stop rule, a clean handoff, and a receipt you read line by line.

02 / Set the cheap model first and keep the prompt small

On my account the cheap side of the rotation is something like DeepSeek V4 Flash or Claude Haiku 4.5. I do not need a big model to rename a function, write a docstring, explain a traceback, or produce three candidate test cases. Those are low-risk, high-frequency tasks, and frequency is what quietly drains a budget.

Before the first prompt, write down the job in one sentence. For me that night it was: merge two CSV tables on the id column and print a per-category total. Then give the model only what it needs: the target file, the two column names, and one example row. Pasting an entire repository into every turn is the fastest way to turn a cheap evening into an expensive one, because input tokens are billed like everything else.

• ■ State the task in one sentence before you type anything.
• ■ Paste the smallest useful slice: one function, one table header, one example row.
• ■ Ask for one change per turn instead of five at once, so a wrong answer costs one small correction instead of a rewrite.
• ■ Keep the conversation on the cheap model until the stop rule says otherwise.

Beginners often ask the cheap model a hard architecture question first, watch it flounder, and conclude the cheap route is useless. That is a workflow mistake, not a model verdict. Give it work that fits its size and it will carry most of your evening.

03 / Write your stop rule before the first prompt, not after

Escalation is where budgets leak, because people decide to escalate on feeling. Tired, impatient, or curious, they switch to the expensive model for a task a cheap one would have finished. My rule is written down and boring: if a fix fails twice on the same problem, or if I cannot state the next step myself after reading the answer, I escalate. Nothing else counts.

Two failed attempts is a real signal. It means the problem has hidden constraints, and continuing to swap prompts on the cheap model is now burning tokens without burning the problem. Before I spend on the expensive model, I give myself a two-minute check: do I actually understand the failing code, and do I have the error output in hand? If I cannot answer both, another cheap turn teaching me the code is worth more than an expensive turn guessing at it.

Keep a tally on paper or in a plain file: cheap turns, escalated turns, and what triggered each escalation. My Sunday session ended at 41 cheap turns and 4 escalated turns. Those 4 turns were the ones where the model had to reason across three files at once, and I would rather pay premium rates 4 times than 41 times.

04 / Hand off cleanly so the expensive model starts warm

Escalation is not a fresh start. If you switch models and re-explain everything from scratch, you pay twice for the same context and lose the cheap model's useful work. Assemble a handoff packet instead, and make the cheap model write it for you on the last turn before you switch.

• ■ One paragraph describing the task and the current state of the code.
• ■ The exact failing command and the exact error output, copied verbatim.
• ■ Two fixes already tried, with why each one was rejected.
• ■ The single question you want answered next.
• ■ Keep the packet under a page. Long packets cost tokens on every later turn.

Because billing follows real usage, the token cost of the cheap model's drafting work is small compared to an expensive model wandering through a confused conversation. The packet also disciplines you: if you cannot write what is stuck, you are not stuck yet.

05 / Read the receipt the way it is actually billed

CheapRelay is a pay-as-you-go AI API relay: one key reaches Claude, GPT, Gemini, DeepSeek, Kimi, GLM, Qwen, Grok and more, and it works with Claude Code, Codex, Gemini CLI and any OpenAI SDK. The API base is https://api.cheapapirelay.com, with OpenAI-compatible routes under /v1 and Gemini native routes under /v1beta. There is no monthly fee and no subscription, which is exactly why your habits matter more than your plan tier.

The important part for a beginner is the billing unit: you pay per real token, and cache reads and cache writes are billed too. Caching is not free money. It makes repeat context cheaper than re-sending it raw, but every cache write is still on the receipt, and every cache read is still a number. So the way to keep an evening at $0.40 is not a clever trick with caches; it is sending fewer, smaller, better-targeted messages and escalating less often.

Check your usage after each session. Divide the total into cheap-turn spend and escalated-turn spend. The ratio tells you whether your stop rule is working. If escalated turns are more than a fifth of your spend, you are probably escalating on mood rather than on evidence.

06 / Four weeks of the habit and the numbers I now expect

After a month of writing the stop rule down, my typical debugging session lands somewhere between $0.25 and $1.00, with escalated turns around 10 to 15 percent of all turns. That is not a market claim, it is my logbook, and yours will move with how large your codebase is and how chatty you are. The shape stays constant though: a long tail of cheap turns, a short spike of expensive ones, and a total you can explain to yourself.

Two practical notes. First, keep one small project running for a week so you see a real trend instead of one lucky evening. Second, if you bring a teammate in, CheapRelay pays a referral reward of 20 percent of what invited users spend, which quietly trims the shared bill while you both learn the habit.

If you want to run this loop yourself, sign up at CheapRelay and start with the cheapest model that can type your code correctly. Spend an hour there first. The receipt will tell you when it is time to reach for more.