How to measure your own Claude Code runs the same way

The figures in Reveneau's Claude Code token benchmark describe one task on one day. Your task is different, and the only figures that describe it are the ones you measure. This page is the method, step by step, so you can measure a setting on your own project the same way and compare two settings under the same conditions. Reveneau is an AI software development consultancy whose code is written by AI; token use is a running cost of every build, and this is how Reveneau measures it. Reveneau is independent of Anthropic.

The words used on this page

A token is a piece of text the model reads or writes. The context window is all the text the model reads in one request. Claude Code sends the whole conversation again on every request; the service stores the unchanged start, and tokens stored this way are cache write tokens, while tokens read back from the store on a later request are cache read tokens [6]. CLAUDE.md is a file of instructions loaded at the start of every session. The effort level is a setting for how much reasoning the model does before each answer. A hook is a shell command Claude Code runs on its own at a fixed point. A non-interactive run is claude -p with a prompt: Claude Code does the task and exits, and Anthropic's documentation, read on 4 October 2026, describes this mode [1]. A turn is one request to the model and its reply, so a run with several tool calls has several turns. A median is the middle value of your sorted runs.

Step 1: choose a task with a test

The task needs a check that does not depend on reading the model's answer. Reveneau's benchmark used a project with one failing test, and the prompt asked for the code to be fixed so the test passed. After each run the test was re-run outside Claude Code, and exit code 0 (the number a command returns to say it succeeded) was a pass. Choose a task of the same shape: something that fails before the run and passes after it, with a command you can run yourself to tell the difference.

Keep the task small while you are learning the method. Every Sonnet run of Reveneau's benchmark task, which took a median of 6 to 10 turns per setting, cost between $0.149 and $0.256 by Claude Code's list-price figure, so five runs per setting are affordable. A long task is a fair thing to measure later, once the method is working.

Step 2: write the prompt once and keep it fixed

Write the prompt in a file or a script and use the same text for every run of every setting. Reveneau's prompt named the test file, the command to run, the folder to change, and told the model to stop when done. If you change the prompt between settings, you have changed two things at once and the comparison is gone. The one exception in Reveneau's benchmark was the hook experiment, which needed a second test file in the command, and the hook experiment page says so.

Step 3: start every run in a fresh copy

Copy the project folder before every run. Inside the copy, run git checkout and git clean so the copy matches the committed state exactly, run Claude Code there, grade the result, and delete the copy. Without this, the second run starts with the first run's fix already in place, and its cost measures nothing. Reveneau's scripts do this with a temporary folder per run.

Step 4: the command and its flags

Run claude -p with your prompt and, at least, these flags. Anthropic's CLI reference, read on 4 October 2026, is the source for each [3].

--output-format json prints one JSON object (a block of structured text that a script can read) at the end instead of plain text [3]; this is where every figure comes from. --max-turns limits the number of agentic turns (the reference's word for turns) and exits with an error at the limit [3]. --max-budget-usd stops the run when the dollar estimate reaches the cap; it applies in print mode, the -p mode, only [3]. Set both caps above what a normal run needs, so that they stop a run that loops and never cut a normal run short; Reveneau used 25 turns and $2 or $3, and no run reached either. --permission-mode sets the mode the session starts in, and acceptEdits approves reads, file edits and common file-system commands without a prompt, by Anthropic's permission modes page [7]; --allowed-tools names the other tools and commands that may run without one, using permission rule syntax such as Bash(node:*) [3]. Redirect standard input (the stream a program reads typed or piped text from) from /dev/null, an empty source, because a -p run reads standard input [1].

Do not use --continue or --resume between runs. Anthropic's documentation says a continued or resumed run reports the conversation's whole total, earlier runs' spend included [1][2], and that a resumed conversation reads its earlier history from the cache [6]. Each run must be a new session so that its json result covers that run alone.

Anthropic recommends --bare for scripted calls, which skips loading hooks, skills, CLAUDE.md and the rest of the working directory's configuration, and which does not use a subscription login [1]. Reveneau did not use it, because the CLAUDE.md experiment needed CLAUDE.md to load. If your question is about a bare run, use the flag; if it is about what a developer's session costs, leave it off, and say which you did.

Step 5: grade, then read the result

After the run, re-run your test command yourself and record the exit code. Then read the json result. The table gives each field, what it counts, and where Anthropic documents it.

Field in the json result	What it counts	Source
total_cost_usd	The dollar figure, computed locally from a bundled price table at list price unless a modelPricing table is in effect; a client-side estimate that can differ from a bill	Anthropic, Track cost and usage [2]; Run Claude Code programmatically [1]
usage.input_tokens	New input tokens, the part of each request neither written to nor read from the cache	Anthropic, Track cost and usage [2]
usage.output_tokens	Tokens the model wrote, including thinking; read it from the result, because per-step values are placeholders	Anthropic, Track cost and usage [2]; Manage costs effectively [4]
usage.cache_read_input_tokens	Tokens read from the cache, charged at a reduced rate	Anthropic, Track cost and usage [2]
usage.cache_creation_input_tokens	Tokens written to the cache, charged at a higher rate than standard input	Anthropic, Track cost and usage [2]
usage.cache_creation.ephemeral_1h_input_tokens and ephemeral_5m_input_tokens	The same cache writes split by lifetime, one hour or five minutes	Anthropic, How Claude Code uses prompt caching [6]
modelUsage	A map from each model's full name to its token counts and cost, which is how you learn what an alias resolved to	Anthropic, Track cost and usage [2]
session_id	The session's identifier	Anthropic, Run Claude Code programmatically [1]
num_turns	The turn count; Reveneau's published scripts read it from the result	the published run.sh and run2.sh

Record all of these for every run, plus the wall-clock seconds (start to finish on an ordinary clock) from your own clock and the exit code of the test. One row per run, as in the published runs.json and runs.csv.

Step 6: five runs, then medians and ranges

Run each setting five times. Identical runs do not cost the same: in Reveneau's benchmark the five low-effort runs on Sonnet ranged from $0.149 to $0.208 by Claude Code's figure, and one of five Opus runs cost $0.612 against $0.488 to $0.490 for the other four. A single run of each setting would have reported whichever of those happened to occur.

Report the median of the five with the minimum and maximum beside it. The median is the middle value when the five are sorted, so one unusual run cannot move it, and the range shows that run instead of hiding it. Reveneau's tables give the median cost, its range, and the medians of the four token counts, the turn count and the seconds. Keep the raw rows and publish them if you publish the medians, so a reader can compute anything you did not.

Then say what the figures are. One task is one task. Medians of five runs describe that task on that day with that version, and nothing wider. Reveneau's limits page is the list for its own run; write yours.

Step 7: record the setup

Four facts belong beside the numbers, because each changes what they mean.

The Claude Code version, from claude --version. Anthropic's costs page says Claude Code regularly receives updates that may change how features work, including cost reporting [4]. Reveneau's run was on 2.1.118.

The resolved model names, from modelUsage. In Reveneau's run sonnet resolved to claude-sonnet-4-6, opus to claude-opus-4-7 and haiku to claude-haiku-4-5-20251001, and Anthropic's current documentation names newer models, so the alias alone is not enough.

Whether the account is a subscription or an API key. Anthropic's prompt caching page says the main conversation gets a one-hour cache lifetime on a Claude subscription within plan usage and five minutes on an API key or cloud provider by default, and that usage.cache_creation in the json result shows which applied [6]. The pricing of a one-hour write differs from a five-minute write, so cache write figures from the two setups are not comparable without this fact. Reveneau's benchmark ran on a subscription, and the dollar figures on every page of this guide are described as Claude Code's own list-price figure on a subscription account for that reason. The prompt caching guide covers the two lifetimes.

The date. Prices, aliases and defaults change, and a figure without a date cannot be checked.

The published scripts

Three scripts are published with the data, and a reader can run or edit them.

run.sh ran the CLAUDE.md experiment. It takes a setting letter, A or B, and a run number. It copies the task folder to a temporary directory, runs git checkout and git clean there, copies the 301-line CLAUDE.md into the folder for setting B only, runs claude -p with the benchmark flags on sonnet with a $2 cap, re-runs the test to grade, reads the fields above from the json result, appends one row to a results file, and deletes the temporary directory.

run2.sh ran the model, effort and hook experiments. It takes its choices as environment variables: the model, the effort level, whether to add the CLAUDE.md, whether to attach the hook with --settings, and whether to add the test that prints 3,000 lines, which also switches the prompt. It runs the same loop with a $3 cap and records the model names from modelUsage in each row.

filter-test-output.sh is the hook used in the fourth experiment, Anthropic's example with two strings changed, which the hook experiment page describes.

The interactive equivalents

In an interactive session the same figures appear in two places. The /usage command's Session block shows the total cost, computed locally at list price, and the token counts by model, which Anthropic's costs page describes [4]; the sister page on how to read /usage and /context explains each line. A status line script receives cost.total_cost_usd, which Anthropic's status line page describes as the estimated session cost computed client-side at list price, along with the context_window fields [5]; the sister page on checking your cache hit rate covers the cache fields it also receives. Both show one session as it runs. For a comparison between two settings you need five fresh runs of each, and that is what claude -p in a script gives you.