Sample issue: your first week in the credits era

Quick summary

• The anchor number: a heavy coding run (~50k in + 15k out) on Fable 5 costs about $1.25. Thirty a day is ~$37.50/day, $1,100+/month.
• Every workflow below attacks that number a different way: split the stack, cache the context, batch the backlog, dial the effort, gate the cheap model.
• All math uses Anthropic's published rates. Where a number is our estimate rather than a published fact, we say so.
• Independent and unofficial. No model access or credits are sold here — you use your own official access.

Workflow 1: The split-stack sprint

When to use it. Any feature where you can describe the task before writing the code — which is most features. Fable 5 does the two things it's uniquely good at (planning and judging), and Sonnet 5 ($2/$10 per million through Aug 31) does the typing in between.

1. Give Fable 5 the task and the relevant interfaces. Ask for a plan, not code (prompt below).
2. Save the plan to a file. It's now an artifact, not a conversation.
3. Open a fresh Sonnet 5 session. Paste the plan and the relevant code. Tell it to follow the plan exactly and flag conflicts instead of improvising.
4. Run your tests between plan steps. Sonnet is the typist; you are still the engineer.
5. When done, send the full diff plus the plan back to Fable 5 for review.
6. Apply fixes in Sonnet, not Fable — the expensive model identifies, the cheap model types.

Copy-ready prompt

You are the planning stage of a two-model pipeline. A cheaper model
(Sonnet 5) will implement your plan without seeing this conversation,
so the plan must be fully self-contained. Task: [describe the feature].
Codebase context: [paste relevant files or interfaces].

Produce: (1) a numbered implementation plan, max 10 steps, each step
small enough to be one file change; (2) exact function signatures and
types for anything new; (3) the edge cases the implementation must
handle; (4) acceptance checks I can run to verify the result.

Do not write the implementation itself. Keep the plan under 800 words.
Flag any step where you are uncertain and say what information would
resolve the uncertainty.

What it costs. Plan on Fable 5 (12k in, 3k out): $0.27. Implementation on Sonnet 5 (60k in across turns, 15k out): $0.27. Review on Fable 5 (25k in, 2.5k out): $0.38. Total ≈ $0.92, versus about $2.00 if Fable 5 had carried the whole session (97k in, 20.5k out). Under half price — and the plan and review, the parts that determine quality, never left the top model.

The cheaper variant. For internal tools and low-stakes code, plan on Sonnet 5 too and reserve Fable 5 for the review step only — you keep the quality gate for about $0.38 a feature.

Workflow 2: Cache-first research synthesis

When to use it. You have a large fixed document set — specs, contracts, a research corpus — and you'll ask it many questions. Re-sending 200k tokens at $10/M for every question is the single most common way people torch credits.

1. Assemble all documents into one block and put it at the start of the request, before any question. Prompt caching matches on an identical prefix; documents after the question won't cache.
2. Mark the document block as a cache breakpoint (see the caching section of Anthropic's API docs for the exact field).
3. First request pays the 5-minute cache write rate: $12.50/M on that prefix.
4. Every request within the cache window reads the prefix at $1/M — a tenth of the standard input rate.
5. Ask questions back-to-back in one sitting so the cache stays warm; write your question list before you start.
6. If your session has long gaps, use the 1-hour cache write ($20/M) instead.
7. Never edit the document block mid-session — any change to the prefix breaks the cache.

Copy-ready prompt (after your cached document block)

Answer the question below using only the documents above. Rules:
cite the document title and section for every claim; if the documents
do not contain the answer, say "not in the documents" — do not fill
gaps from general knowledge; if two documents disagree, present both
positions and name the sources rather than picking a winner.

Format: a direct answer in 3 sentences or fewer, then a bulleted list
of supporting citations, then a final section titled "Gaps and
contradictions" listing anything the documents leave unresolved.
Keep the whole response under 300 words unless the question
explicitly asks for depth.

Question: [your question]

What it costs. A 200k-token corpus, 10 questions. Uncached: 10 × 200k × $10/M = $20.00 in input alone. Cached: one write ($2.50) + 9 hits at $0.20 each = $4.30. Output (say 10 × 1k tokens) adds $0.50 either way. You save about $15 per 10-question session, and the savings scale with corpus size.

The cheaper variant. Run the same cached setup on Sonnet 5 for first-pass extraction, then send only the contested findings to Fable 5 for adjudication.

Workflow 3: The overnight batch grinder

When to use it. Anything you don't need in the next hour: test generation, docstring passes, migration scaffolding, changelog drafts. The Batch API runs asynchronously and cuts Fable 5 to $5/M in, $25/M out — a flat 50% off.

1. Keep a running "batch backlog" file during the day. When a task isn't urgent, don't run it — write it down.
2. At end of day, turn each backlog item into one self-contained request (the prompt below is a test-generation template).
3. Submit the whole set as one batch job before you log off.
4. In the morning, pull results and eyeball them before committing anything — batch output gets the same scrutiny as interactive output.
5. Anything that came back wrong goes into an interactive session for a targeted fix, not a full re-run.

Copy-ready prompt (one per module, via Batch API)

Write unit tests for the module below. Requirements: use [pytest /
vitest — name your framework]; cover the happy path, every documented
error condition, and boundary values for any numeric or length-limited
input; one behavior per test, named test_<behavior>; no network or
filesystem access — mock external calls; include at least one test
that would fail if the main function's return type changed.

Output only the test file, no explanation. If parts of the module are
untestable as written (module-level globals, hidden state, hard-coded
dependencies), do not write brittle tests for them — instead add a
TODO comment block at the top of the file listing each untestable
part and why.

Module:
[paste module code]

What it costs. Thirty modules at ~8k in + 4k out each: 240k in × $5/M = $1.20, plus 120k out × $25/M = $3.00. Total $4.20 for a night's work that would cost $8.40 interactively on Fable 5.

The cheaper variant. Test generation rarely needs the top model. The same batch on Sonnet 5's batch rate ($1/$5) costs $0.84 — then let Workflow 5's quality gate catch the misses.

Workflow 4: The effort dial

When to use it. Fable 5's API has an effort parameter — default high, with xhigh for capability-critical work and medium/low for routine tasks. This is Anthropic's own prompting guidance, and almost nobody reads it: people pay for maximum deliberation on tasks like renames and format conversions that don't need it.

1. Sort your Fable 5 tasks into two piles: judgment tasks (architecture, debugging unknowns, review) and mechanical tasks (renames, conversions, boilerplate against a clear spec).
2. Leave judgment tasks at high. Save xhigh for the genuinely hard calls.
3. Set effort: "medium" on mechanical tasks, and pair it with a prompt that forbids commentary (below).
4. Log output tokens per task type for a week at each setting.
5. Every 1,000 output tokens you shave is $0.05 back — measure your own delta rather than trusting anyone's number, ours included.
6. If a medium-effort run gets something wrong, that task type goes back in the judgment pile. The dial is per-task-type, not global.

Copy-ready prompt (with effort: "medium" set in the API call)

This is routine, mechanical work. Keep reasoning brief and output
minimal. Task: rename every configuration key in the file below from
camelCase to snake_case, update every internal reference to those
keys, and preserve all comments, ordering, and formatting exactly.

Output only the changed file — no explanation, no summary of what you
did, no restating of the task. If any rename is ambiguous (a key that
would collide with an existing name after conversion, or a string
that might be user-facing rather than internal), do not guess: stop
and output only a list of the ambiguous cases with one line on why
each is ambiguous.

File:
[paste file]

What it costs. Output is the expensive side: at $50/M, a chatty 15k-token response costs $0.75 while a disciplined 6k-token response costs $0.30. If medium effort plus a no-commentary prompt trims your average mechanical run from 15k to 8k output tokens — an illustrative ratio, not a published one; measure your own — that's $0.35 back per run, about $10.50/day at 30 runs.

The cheaper variant. If a task is safe at effort: "low", it's usually safe on Sonnet 5 at $2/$10 — try the model swap before the dial.

Workflow 5: The GLM quality-gate

When to use it. High-volume, low-individual-stakes work: bulk refactors, data labeling, lint-fix sweeps across many files. GLM-5.2 is open-weight (MIT), roughly one-sixth the cost of Opus 4.8, and close to it on coding per the third-party FrontierSWE benchmark — and you can self-host it.

1. Route the full volume run through GLM-5.2 (hosted or self-hosted).
2. Randomly sample 10% of the outputs. Random — not the ones that look suspicious, or you'll only ever confirm what you already noticed.
3. Send each sampled task + output to Fable 5 with the judge prompt below.
4. If the sample's failure rate is under your bar (we use ~5% FIX-or-worse), ship the batch.
5. If it's over, read the judge's failure descriptions, fix the instructions you gave GLM, and re-run the failed category — don't hand the whole job to Fable 5 out of panic.
6. Track the failure rate per task type; some work will earn its way off the gate entirely.

Copy-ready prompt

You are auditing the output of a cheaper model. Below is the task it
was given and the output it produced. Score the output 1-5 on three
axes: correctness (does it do exactly what the task asked), safety
(does it break anything adjacent to what it touched), and
completeness (are edge cases handled).

For every score below 4, quote the exact line that is wrong and state
the fix in one sentence. Then give one verdict: SHIP, FIX (with the
numbered list of fixes), or REDO (if the whole approach is wrong, say
what approach to use instead). Do not rewrite the output yourself.
Be strict: a plausible-looking answer that silently skips an edge
case is a 3, not a 4.

Task: [paste the original task]
Output: [paste the cheaper model's output]

What it costs. 100 tasks at ~10k in + 3k out. On Fable 5 directly: $10.00 in + $15.00 out = $25.00. Via GLM-5.2 at roughly one-sixth of Opus 4.8's rates: about $2 for the volume (check your provider's actual rate card), plus 10 Fable 5 judge calls (~5k in + 1k out each): $1.00. Total ≈ $3 for work that would have cost $25.

The cheaper variant. Use Haiku 4.5 ($1/$5) as a pre-filter judge on all 100 outputs (~$1.50) and send only its flagged items to Fable 5.

This is the real format

Real runbooks, prompts you can paste without editing, and math from published rates instead of vibes. Members get an issue like this every week — new workflows as pricing and models shift, corrections when we get something wrong, and the token-saving claims circulating on Twitter tested rather than retweeted. If this sample wasn't useful, the paid issues won't be either — that's the honest bar.

• Join the Field Guide $12/month or $79/year — cancel anytime
• What Fable 5 costs now the free credits-math guide