DEV Community: Johmisking

Same model, 68% to 88% fewer tokens: Antigravity CLI vs Claude Code vs Codex, measured

Johmisking — Thu, 22 Oct 2026 15:23:39 +0000

Google stopped serving Gemini CLI to personal accounts on June 18, 2026 and moved people to its new Antigravity CLI (agy). Antigravity can run Claude models too, which makes a rare test possible: the same model, Claude Opus 5.5, in two different coding tools. So I ran Antigravity CLI, Claude Code and Codex on the same prompts, 44 runs in total, and checked every game they built in a headless browser.

How I measured

Windows 11, 2026-10-22. Every run in its own empty folder, one after another
Claude Code 2.1.295 with Opus 5.5 (Max plan)
Codex CLI 0.162 with gpt-6-luna (ChatGPT plan)
Antigravity CLI 1.4.5 with Gemini 4 Argon and with Claude Opus 5.5 (personal Google account)
Startup test: "Reply with the single word OK." with 0, 1, 10 and 30 dummy MCP tools, 2 runs each
Task: a brick-breaker game in one index.html with 2 levels, a score and 3 lives, medium effort, 3 runs each
Token counts are what each CLI reports in its JSON output

Result 1: tokens before doing anything

Tool	Input tokens for "OK"
Claude Code + Opus 5.5	35,781
Codex + gpt-6-luna	14,818
Antigravity + Gemini 4 Argon	6,745
Antigravity + Opus 5.5	5,326 (+5,167 cache reads)

Most of this is each tool's own instructions and tool definitions, which go out again with every request.

Result 2: the same coding task

Tool	Input	Output	Seconds	Lines	Games working
Claude Code + Opus 5.5	78,671	7,313	58	451	3 of 3
Codex + gpt-6-luna	55,680	4,563	68	42 (minified)	3 of 3
Antigravity + Gemini 4 Argon	13,041 (+6,796 cache)	6,373	81	608	3 of 3
Antigravity + Opus 5.5	9,822 (+15,381 cache)	4,378	42	236	3 of 3

With the same Opus 5.5, Antigravity read 68% to 88% fewer input tokens than Claude Code, wrote 40% fewer output tokens and finished 27% faster. Claude Code's games were longer (451 lines against 236), and Claude Code put each run at $0.37 at API prices. Antigravity and Codex show no price on a subscription.

All 12 games worked: the score rises when bricks break, level 2 appears, lives go 3, 2, 1, 0. My automatic check could not read the score in two of the Codex games, so I checked those by hand; both scored.

Why a range, not one number

Antigravity's JSON reports input_tokens and cache_read_tokens separately, and its documentation does not say whether one contains the other. In the Opus runs the cache reads (15,381) were larger than the input (9,822), so there they cannot be inside it. I show both: the reported input as the low end (88% fewer) and input plus cache reads as the high end (68% fewer). Even the high end is far below Claude Code.

MCP tools barely matter any more

	30 MCP tools added
Claude Code	+388 tokens
Codex	+0
Antigravity + Gemini	+582
Antigravity + Opus	+417

In Antigravity one tool already added about 280 to 460 tokens and the next 29 added little. All four setups now seem to load a tool's full definition only when it is used.

What to take away

The coding tool around the model matters as much as the model. The same Opus 5.5 read a fraction of the input in Antigravity.
Fewer tokens is not the same as a better result. Claude Code wrote longer games; all of them worked in every tool.
If you were on Gemini CLI with a personal account, Antigravity CLI is the replacement, and it is lean.

Limits

2 runs per startup test, 3 per game. One task, one machine, one day
Each tool counts cache differently, so compare within a tool's own column with care
I cannot see how Antigravity sets up Opus 5.5 behind its claude-opus-5-5-medium name

Data

Full data, per-run CSV and method (CC BY 4.0, DOI 10.5281/zenodo.23569397): https://tokensave.app/data/antigravity-cli-vs-claude-code-vs-codex
The earlier Claude Code vs Codex test: https://tokensave.app/data/claude-code-vs-codex-tokens

How many tokens does Blender MCP really use? 72 Claude Code runs, and a racing scene for $0.47

Johmisking — Thu, 22 Oct 2026 12:17:50 +0000

People say hooking Blender up to Claude through MCP eats tokens. I couldn't find a single measurement, so I took the most popular server, MCP for Blender, and ran it 72 times in Claude Code: describing scenes, building furniture, recolouring and checking with screenshots, two worst cases, and one showcase, a racing car with a chase camera. I also ran every task through the small proxy I built for browser MCP, now version 0.3, to see whether it helps here.

How I measured

Claude Code 2.1.295, Opus 5.5, effort medium, Windows 11 with a GTX 1650 (2026-10-22)
Blender 5.2.2 LTS, MCP for Blender via uvx mcp-for-blender (add-on 1.8, telemetry off)
Only the Blender server attached; web, file and shell tools disabled, and the server's 3D-generation and asset-download tools too
Scenes made by my own script, identical every run: a room with 13 objects, a city block with 580 objects, and an empty scene
Every run checked afterwards by reading the saved .blend file: the table and four chairs exist, the chairs are really red, the animation is 120 frames, the camera follows the car. 72 of 72 passed.

Result 1: everyday tasks cost $0.16 to $0.23

Task (5 runs each)	Input tokens	Cost
Describe a small room	69,606	$0.16
Describe a 580-object city block	115,868	$0.19
Build a low-poly table and four chairs	125,563	$0.23
Make the chairs red, then check with a screenshot	124,649	$0.20
Look at the table from four sides	112,118	$0.21

(Cost at Opus 5.5 API prices, as reported by Claude Code.)

The largest text result in these 25 runs was 2,347 characters. The current MCP for Blender is already careful: scene info lists 20 objects per call by default and screenshots default to 768 pixels. Most of each request (about 25,000 tokens) is Claude Code's own instructions, sent again at every step.

Result 2: a racing scene cost $0.47

I asked for a low-poly racing car of its own design, a circuit with a corner, a 5-second animation through the corner and a chase camera. Claude did it in about 10 requests and 93 seconds, for $0.47 on average ($0.42 to $0.56 over 5 runs). All 10 runs, with and without the proxy, produced a working animation. I rendered them afterwards in EEVEE; that took about 90 seconds per clip on the GTX 1650 and is not part of the measured cost.

Result 3: the one expensive case is a long script output

I asked Claude to print every property of all 580 objects. The script returned 122,373 characters. Claude Code refused it as too large, so Claude ran it again in four chunks of about 32,000 characters each, and all four stayed in the context:

242,782 input tokens, $0.87 per task, more than four times an everyday task

Printing all 19,042 vertices of a sphere did not get that far: Claude Code refused it, and Claude reported that the vertices were printed and stopped there: $0.17.

The proxy: tokensave-mcp-diet 0.3

It sits in front of the server and passes every tool through. For Blender, version 0.3 does two things:

Long text results (over 8,000 characters) keep their first 2,000 and last 1,000 characters plus a summary of the hidden middle. On the property dump it read: "568 lines (132,418 characters) hidden ... 568 lines like: name=Building ## | type=MESH | location=(#, #, #) ...". The full text stays in memory, and a new tool result_detail returns any part by line range or search.
Smaller images by default: tools with a max_size get 512 pixels unless the model asks for more than 1,000.

Setup:

{
  "mcpServers": {
    "blender": {
      "command": "npx",
      "args": ["-y", "github:johnisking/tokensave-mcp-diet", "--", "uvx", "mcp-for-blender"]
    }
  }
}

Task	Cost, as shipped	With the proxy	Change
Print every property of 580 objects (3 runs)	$0.873	$0.166	−81%
Racing scene (5 runs)	$0.471	$0.445	−6%
Everyday tasks (5 runs each)	$0.16 to $0.23	$0.15 to $0.21	−4% to −8%

To be honest about the rest: the proxy cut image tokens on the racing scene by 62%, but images were a small part of the input, so the scene cost only 6% less, and that is within run-to-run noise. The small-room description, where the proxy changed nothing at all, came out 4% cheaper too. So the everyday differences are noise. The proxy is a safety net for the long-output case, not a discount on every task.

One bug I hit on the way: MCP for Blender also returns each result as structuredContent, and Claude Code shows that instead of the text, so my first diet runs of the long-output task were not shortened at all. Version 0.3 now shortens those fields too, and I re-ran those tasks after the fix.

What to take away

Blender MCP in Claude Code is not a token hog for normal work. Cost follows the number of steps, and most of each step is Claude Code itself.
Watch out for scripts that print a lot. One property dump cost more than four normal tasks. Ask for counts, summaries or a file instead of "print everything".
If you use a client that passes large tool results straight through, the same dump would land in the context in one piece. That is where a proxy like this pays off most.

Limits

One model, one machine, one client. 5 runs per task (3 for the two worst cases).
Costs vary by run because Claude takes a different number of steps each time.
Image tokens are estimated from image size (width × height / 750); the input totals are exact.
MCP for Blender changes fast; this is the 2026-10 version.

Data

Full data, method and per-run CSV (CC BY 4.0, DOI 10.5281/zenodo.23562484): https://tokensave.app/data/blender-mcp-token-cost
tokensave-mcp-diet (MIT): https://github.com/johnisking/tokensave-mcp-diet
The same test for browser MCP: https://tokensave.app/data/browser-mcp-token-cost

Browser MCP token cost: 68 runs of Playwright MCP vs Chrome DevTools MCP, and a proxy that cuts snapshots by up to 96%

Johmisking — Thu, 22 Oct 2026 06:06:30 +0000

You often hear that hooking a browser MCP server up to Claude Code burns tokens, and some posts put it at 10,000 to 50,000 tokens every time the agent looks at a page. I wanted to know whether that holds up, and whether it can be reduced, so I measured the two most popular servers: Microsoft's Playwright MCP and Google's Chrome DevTools MCP. Along the way I ended up building a small tool to cut the cost, so the results for that are here too.

How I measured

Claude Code 2.1.295, Opus 5.5, effort medium, Windows 11 (2026-10-22)
Exactly one MCP server per run; web search, web fetch, file tools and shell were disabled, so only the browser tools could be used
Playwright MCP 0.0.83 and Chrome DevTools MCP 1.11.0, both headless
7 tasks: 2 runs each for everyday tasks, 5 runs each for snapshot tasks (3 for the full-snapshot probe), 68 runs in total
Tokens come from the per-request usage in Claude Code's log (all input: uncached, cache read and cache write)

Result 1: everyday tasks were lighter than expected

Task	Playwright input tokens	Cost	Chrome DevTools input tokens	Cost
TodoMVC: add 3 items, complete 1	178,408	$0.19	199,737	$0.22
Wikipedia: who designed Python, first year	115,888	$0.17	117,240	$0.17
Hacker News: top 5 stories	90,006	$0.16	93,496	$0.17
Wikipedia table: 5 release dates	91,350	$0.16	93,683	$0.16

(Average of 2 runs, cost at Opus 5.5 API prices.)

All 16 runs got the right answer, and the largest single tool result was 6,012 characters. Opus 5.5 did not read whole pages. It ran short scripts that pulled out just what it needed, or used Playwright's find tool.

So where did the tokens go? Each request carried about 23,000 tokens, and most of that was Claude Code's own instructions and tool definitions, not the browser. Browser work takes many small steps, and that fixed amount is sent again with every step. The to-do task was the most expensive not because the page was big but because it took the most clicks and keystrokes.

Result 2: reading a long page in one go is over 200,000 tokens

Then I forced the worst case: open the English Wikipedia article "Python (programming language)" and take one accessibility snapshot of the whole page.

Playwright MCP: 504,168 characters
Chrome DevTools MCP: 427,400 characters

I sent that text to Opus 5.5 to count it: 205,642 and 208,926 tokens. That is about $1.65 for one snapshot at Opus list price. OpenAI's o200k tokenizer counts 133,668 and 138,745, so the same text comes out more than 50% bigger on Claude. Text full of link targets and element ids is especially expensive for Claude's tokenizer.

The good news: Claude Code already stops this. Every time, it refused the result as too large, saved it to a file and told the model to read it in pieces. So 200,000 tokens never landed in the context in Claude Code. A client without that guard could take the whole page in one go. I only measured Claude Code, so I can't say which other clients do that.

Result 3: medium pages get straight through

Pages Claude Code does not block are the real issue. The Hacker News front page snapshot came straight in and grew the next request by:

Playwright MCP: 18,407 tokens
Chrome DevTools MCP: 14,115 tokens

Most of that is noise: a URL line under every link, "clickable" markers, empty layout cells, "|" separators and deep indentation.

So I built a proxy: tokensave-mcp-diet

It sits in front of Playwright MCP or Chrome DevTools MCP and does three things:

Compact: if a snapshot is large, strip link targets, cursor markers, separators and empty wrappers, and shrink the indentation. Element refs stay, so clicking and typing work as before.
Outline: if it is still too big, send only headings, form fields, buttons and links, with long runs of links (like Wikipedia's references) collapsed.
Read on demand: keep the full snapshot in memory and add a snapshot_detail tool that returns any part of it by ref or by text.

Setup is one change in your MCP config. No npm account or API key:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "github:johnisking/tokensave-mcp-diet", "--", "npx", "-y", "@playwright/mcp@latest"]
    }
  }
}

Same tasks, with and without it:

Task	Server	Snapshot tokens, as shipped	With the diet	Task cost
Hacker News top 5	Playwright	18,407	6,792 (−63%)	$0.298 → $0.205 (−31%)
Hacker News top 5	Chrome DevTools	14,115	8,066 (−43%)	$0.271 → $0.224 (−18%)
Wikipedia facts	Playwright	refused in 3 of 5 runs	9,193	$0.181 → $0.236 (+30%)
Wikipedia facts	Chrome DevTools	refused every time	8,479	$0.230 → $0.237 (+3%)
Wikipedia full snapshot	Playwright	about 205,600 (refused by Claude Code)	9,193 (−96%)	$0.154 → $0.222 (+44%)
Wikipedia full snapshot	Chrome DevTools	about 208,900 (refused by Claude Code)	8,479 (−96%)	$0.160 → $0.221 (+38%)

(Cost is the average of 5 runs, 3 for the full snapshot. On Hacker News the 5 runs were within one cent of each other, and snapshot tokens varied by at most 4% between runs.)

On Hacker News, snapshot tokens fell 43% to 63% and the task cost 18% to 31% less, with the same answer in all 5 runs.

To be honest about Wikipedia: inside Claude Code the proxy lost money. Where Claude Code would have sent a short refusal note, the proxy sent a 9,000-token outline, and the task cost 3% to 44% more. In a client that passes large results through, the same outline turns 200,000 tokens into 9,000, a 96% cut. The tool pays off on medium-size pages, and in clients that don't have Claude Code's guard.

Update (same day): version 0.2 fixes the Wikipedia loss. Pages over 60,000 characters now get only a table of contents (headings with their refs, about 1,100 tokens), and a heading ref returns that whole section. Re-measured with 5 runs each: finding facts on the Wikipedia article now costs $0.181 → $0.173 (−4%) on Playwright and $0.230 → $0.178 (−23%) on Chrome DevTools, a bare full snapshot costs about the same as Claude Code's own refusal (+2% and +3%), and Hacker News stays at −30% and −17%. The full Wikipedia snapshot goes from about 205,600 Claude tokens to about 1,140 (−99%). The install command above now gets 0.2.

What to take away

In Claude Code, most of the browser-MCP bill is the number of steps, not the pages. Saying clearly what you want, so the agent finishes in fewer steps, helps most.
The expensive request is "read the whole page". Ask for a specific element, a search or a short script instead.
If your client passes large tool results straight through, put a proxy like tokensave-mcp-diet in front, or turn on a server option that saves snapshots to files.

Limits

2 runs per everyday task, 5 per snapshot task (3 for the full snapshot), one model, one machine. Hacker News is live, so points changed between runs.
Only Claude Code was measured. I did not check whether Claude Desktop, Cursor or Codex pass a 200,000-token result through.
Snapshot formats change between server versions. Playwright MCP already saves the snapshot to a file on navigation.
The outline drops body text, so the model has to ask for details, which can add steps.

Conclusion

Browser MCP does not burn huge numbers of tokens on every step. Opus 5.5 mostly read only what it needed, and the cost was driven by Claude Code's fixed per-request block and the number of steps. But one full read of a long page is over 200,000 tokens, and medium pages get through even in Claude Code. tokensave-mcp-diet is a free tool for those two cases.

Full data (CSV, CC BY 4.0): https://tokensave.app/data/browser-mcp-token-cost
tokensave-mcp-diet (MIT): https://github.com/johnisking/tokensave-mcp-diet
Count the tokens in your own prompt: https://tokensave.app/

Gemini 4 Argon has a new tokenizer: Korean and Japanese got 8% cheaper, Indian languages up to 19% dearer

Johmisking — Wed, 21 Oct 2026 12:13:51 +0000

Gemini 4 Argon ships with a new tokenizer. The same text no longer gives the same token count as on Gemini 3.x, and token counts are what you pay for and what fills the context window. So I measured what changed, in 41 languages.

The short version:

Korean needs 8% fewer tokens and Japanese 7% fewer for the same text. English did not change by a single token.
Indian languages went the other way: Hindi, Tamil and Kannada need 12% to 19% more.
Added up over all 41 languages the change is only +0.7%. The tokenizer did not get better or worse overall; the cost moved between languages.

The test

10 everyday requests (write a function, plan a trip, a product description, meeting notes and so on), translated into 41 languages: 410 texts
Counted in the Google AI Studio token counter on Gemini 4 Argon and Gemini 3.8 Flash, 2026-10-21. Gemini 3.8 Flash and 3.1 Pro gave identical counts in an earlier test, so I call them 3.x
The counter adds a fixed amount, which I subtracted: on Argon the one-letter text "a" shows 32, so 31; on 3.8 Flash it shows 2, so 1
GPT (o200k) and Claude Haiku 5.5 numbers are from the same 410 texts, measured earlier

Result 1: the same 10 texts, before and after

Language	Gemini 3.x	Gemini 4 Argon	Change
English	373	373	0%
Chinese (Simplified)	360	354	-2%
Japanese	417	387	-7%
Korean	498	456	-8%
Hindi	470	528	+12%
Kannada	679	794	+17%
Tamil	568	675	+19%

What matters is that the direction is consistent. English was identical on all 10 texts. Korean and Japanese went down on all 10 (-3% to -15% per text), and Hindi, Kannada and Tamil went up on all 10 (+6% to +31% per text). This is the tokenizer, not one odd sentence.

In characters it reads like this: one Korean token now holds 1.94 characters instead of 1.78, so the same context window fits about 9% more Korean text. One Kannada token went from 2.71 characters to 2.32.

Result 2: group by script and a pattern appears

All 41 languages (one request text each), grouped by writing system. Numbers are the median change from Gemini 3.x.

Script	Languages	Median change	Range
Indic scripts (Hindi, Bengali, Tamil, ...)	10	+17%	-8% to +24%
Chinese, Japanese, Korean	4	-6%	-15% to -3%
Thai	1	-9%
Arabic, Persian, Hebrew	3	-5%	-6% to -3%
Latin (English, Spanish, ...)	20	-2%	-10% to +3%
Cyrillic, Greek	3	0%

9 of the 10 Indic-script languages went up (the exception is Punjabi, -8%), and all four CJK languages went down. Among Latin-script languages, English, German and French stayed put, while languages with long, heavily inflected words dropped: Finnish -10%, Hungarian -8%, Polish -7%. Russian, Ukrainian and Greek did not change by a single token.

What it suggests: same total, different split

Summed over the 41 texts, Gemini 3.x needs 2,069 tokens and Argon 2,083, a difference of +0.7%. The median "language tax" (extra tokens versus English) is +41% on both.

A tokenizer splits text using a vocabulary of fixed size. Languages whose common character sequences get more entries in that vocabulary need fewer tokens. These results look like what you would expect if part of the vocabulary moved from Indic scripts to CJK and some European languages. Google has not described the change, so this is an inference from the measurements, not a confirmed fact.

Gemini's edge in Indian languages mostly went away

Gemini 3.x was unusually efficient for Indian languages. Much of that advantage is gone in Argon. Tokens for the one request text:

Language	GPT (o200k)	Gemini 3.x	Gemini 4 Argon
Hindi	51	41 (-20% vs GPT)	48 (-6%)
Bengali	57	39 (-32%)	46 (-19%)
Tamil	67	52 (-22%)	63 (-6%)
Kannada	61	58 (-5%)	72 (+18%)
Malayalam	63	65 (+3%)	71 (+13%)

Hindi went from 20% fewer tokens than GPT to 6% fewer, and Kannada and Malayalam now need more than GPT.

Next to the other models

Total tokens for the same 10 texts:

Language	Gemini 4 Argon	GPT (o200k)	Claude Haiku 5.5
English	373	350	520
Korean	456	534	935
Japanese	387	570	684
Hindi	528	565	1,223
Kannada	794	679	3,276

In English GPT needs 6% fewer tokens than Argon, but in Korean the order flips: Argon needs 15% fewer than GPT and 51% fewer than Claude. Fewer tokens is not automatically cheaper, since the price per token differs by model.

What changes in practice

Korean or Japanese on Gemini: at the same price per token, input costs drop 7% to 8%, and the same context window holds more text. Token-based limits and free tiers last correspondingly longer.
Indian-language products moving from 3.x to Argon: budget for 10% to 20% more input tokens on the same traffic. For Kannada and Malayalam, GPT now needs fewer tokens.
English-only products: no change in token counts.
Cost estimators: rules of thumb like "characters divided by a constant" tuned on 3.x no longer hold for Korean or Indian languages. Measure per model.

Limits

Input tokens only. Output very likely uses the same tokenizer, but I did not check it
The 10-text comparison with Gemini 3.x covers 7 languages. The 41-language comparison uses one text, so single languages can move by a few percentage points; on that text Korean showed a larger -15%
AI Studio counter numbers; the API's countTokens may differ by a few tokens
The vocabulary explanation is an inference from the data, not something Google has confirmed

All 41 languages, chart and CSV (CC BY 4.0): https://tokensave.app/data/language-tax-index
Count your own text: https://tokensave.app

Sending text as images cut my Claude tokens by up to 81%. It also started inventing numbers.

Johmisking — Wed, 21 Oct 2026 07:14:03 +0000

There is a trick going around for cutting Claude Code bills: render bulky context (system prompt, tool docs, logs, old history) as dense PNG images instead of text. An image is billed by its pixel size, not by how much text is inside it, so a page packed with small characters can cost far fewer tokens than the same text.

The open-source proxy pxpipe does exactly this and reports a 59-70% lower bill. Its own README is honest that the method is lossy. I wanted an independent number for both sides: how many tokens it really saves, and what the model can still read back.

The test

Six documents, 10,600 to 23,200 characters: one of our articles in English, Korean and Japanese, a JavaScript file, a generated JSON API response and a generated 230-line server log
Planted in each: five lines like "ticket T123 uses build hash 3f9a1c7e02bd and a timeout of 19043 ms". For the JSON and the log I also asked about five records that were already there
Three ways to send it: plain text, pxpipe's own output (page images plus its text "factsheet" of exact identifiers), and the images alone
Claude Haiku 5.5, Sonnet 5.5, Opus 5.5 and Fable 5.1 through Claude Code, 2 runs each, 144 calls, exact-match scoring
System prompt: answer from the document only, null if unsure

Tokens: the saving is real

Document	As text	As pxpipe images	Change
English prose	5,870	2,100	-64%
Korean prose	9,483	2,142	-77%
Japanese prose	8,678	2,374	-73%
Code	7,586	1,906	-75%
JSON	8,274	2,022	-76%
Server log	13,053	2,935	-78%

(Opus 5.5; Haiku and Sonnet were the same within a few tokens. Fable's denser layout: -68% to -81%.)

The more tokens a language costs as text, the more an image saves. Korean and Japanese gained the most.

Exact values: this is where it breaks

As plain text, every model answered every item correctly. Through pxpipe:

Model	Planted ids	Planted numbers	Other ids in JSON/log
Haiku 5.5	21/60	22/60	0/20
Sonnet 5.5	49/60	40/60	0/20
Opus 5.5	58/60	44/60	0/20
Fable 5.1	41/60	28/60	0/20

Three things stood out:

The ids came back through the factsheet, not the image. All planted ids happened to be in pxpipe's text list. The log had 235 ids and only 94 made the list. The ids that were left out were read 0 of 80 times, across all four models.
Numbers were the weak spot. Opus 5.5, the best here, got 44 of 60. In Korean prose it got 3 of 10.
Wrong answers looked right. Despite "null if unsure", models sometimes returned a plausible wrong value: 94392 read as 9392, a number that is not in the document, or (Fable 5.1) a real value from the factsheet attached to the wrong ticket.

So when is it worth it?

Use image context for what the model needs to understand, not for what it needs to copy. A long article to summarize, a design doc to review, old conversation history: fine. Ids, hashes, prices, line numbers, code you want edited: keep them as text.

I added a button for it

Because the saving is large for long non-English text, I added an experimental Text → image button to the free token counter at https://tokensave.app. It renders your text into PNG pages in the browser (nothing is uploaded), estimates the image tokens for the GPT, Claude or Gemini model you picked next to the text tokens, and lets you copy or download the pages. A 9,000-character Korean article came out at about 1,400 image tokens on Claude versus 8,229 as text.

Two caveats. The button uses a larger, plainer font than pxpipe's 5x8 pixel cells, so it saves somewhat less and I have not measured its read-back accuracy yet. And the warning above applies: do not use it for anything that has to be exact.

Limits of this test

Two runs per cell and six documents, so treat single cells as examples. I measured exact recall only; pxpipe's own tests report good results on gist and arithmetic questions, which I did not repeat. In normal use pxpipe images older history and the system prompt while recent turns stay text, so the saving on a full bill depends on your session.

Full tables, method and CSV (CC BY 4.0): https://tokensave.app/data/text-as-image-token-cost
Corpus, rendered pages, raw answers and scripts: https://github.com/johnisking/token-cost-by-language/tree/main/text-as-image

I paused Claude Code for 0 to 65 minutes to see when the prompt cache expires

Johmisking — Tue, 20 Oct 2026 10:50:34 +0000

You work in Claude Code all morning, go to lunch, come back and send one more message. The first reply is slow and your usage jumps. The usual suspect is the prompt cache: once it expires, the next message has to re-process the whole conversation.

But how long does the cache actually last? Guides say five minutes, others say an hour, and in April 2026 there was a whole controversy about it. I couldn't find anyone who had simply waited and measured, so I did.

The test

Claude Code 2.1.295, Opus 5.5, medium effort, signed in with a subscription, headless (-p), no MCP servers
Turn 1: build a small brick-breaker game in one index.html
Wait 0, 4, 6, 15, 30, 55 or 65 minutes
Turn 2 in the same session (--resume): "Make the ball red and slightly faster."
Each pause in its own session, all started within a minute of each other, run twice (October 20, 2026)

If the cache lasts five minutes, the cost should jump between 4 and 6 minutes. If it lasts an hour, between 55 and 65.

Results

First model call of the next message, mean of two runs. Cost is Claude Code's API list-price estimate.

Pause	Read from cache	Written to cache	Next message cost
0 min	41,436	496	$0.039
4 min	43,232	466	$0.042
6 min	42,440	496	$0.042
15 min	43,076	502	$0.041
30 min	42,636	494	$0.043
55 min	43,183	502	$0.043
65 min	15,925	27,460	$0.253

Up to 55 minutes nothing changed. At 65 minutes the cache was gone: 27,460 tokens had to be written again and the same message cost 507% more. Both runs agreed. Every cache write in the log was ephemeral_1h.

Why an hour, and when it's five minutes

Per Claude Code's docs, the default lifetime depends on how you sign in:

How you sign in	Main conversation	Subagents, compaction, etc.
Subscription, within included usage	1 hour	5 minutes
Subscription, drawing on usage credits	5 minutes	5 minutes
API key or cloud provider	5 minutes	5 minutes

On Opus 5.5 a one-hour cache write costs $8 per million tokens (+100% vs normal input), a cache read $0.20 (-95%). So the expiry tax grows with conversation size: re-writing a 200,000-token conversation costs about $1.60 before your message does anything.

Before a long break

We only measured pause lengths; these come from the docs:

Under an hour: do nothing.
Long break, same task: /compact before you leave. It's cheap while the cache is warm, and leaves only a small summary to re-cache.
Long break, new task: /clear (the docs say it costs nothing).
Check: from v2.1.251, /usage shows whether the cache is warm or cold.
Choose the TTL yourself: promptCacheTtl (5m or 1h, v2.1.242+). Run claude -p "hello" --output-format json and look for ephemeral_1h_input_tokens vs ephemeral_5m_input_tokens to see which you get.

One small project and two runs, so treat the exact numbers as an example. The full write-up, with the pricing table, the bigger-session math and the limitations, is here:

👉 https://tokensave.app/blog/claude-code-cache-break-cost

Raw logs and CSV are open under CC BY 4.0.

Do AI coding agents search the web in your language? I tested Claude Code and Codex in 5 languages

Johmisking — Mon, 19 Oct 2026 02:31:24 +0000

When you ask an AI agent something in Korean or Spanish, does it search in that language? I ran 320 web-search sessions with Claude Code (Opus 5.5) and Codex CLI to find out.

Global topic (AI products), asked in Korean, Japanese, Spanish or Ukrainian:

205 of 206 searches were in English.
0 of the 222 cited pages were in the question's language.

Local topic (metro fare, this week's news, restaurants in Seoul, Tokyo, Madrid, Kyiv), 5 runs per question:

	Claude Code	Codex
Asked in the local language: searches in that language	82%	50%
Asked in English: searches in the local language	49%	17%

Asked in English about Tokyo, Codex searched in Japanese 1 time out of 56.
Madrid was the exception for both: even in English, most cited pages were Spanish (Claude 42 of 53, Codex 26 of 31).
Asked in Ukrainian for Ukraine's news, all 15 links Codex cited were English-language outlets.
All 320 answers came back in the language of the question, so you usually can't tell from the answer which language the sources were in.

Why it matters: if you publish in a language other than English, AI agents may only find you for local topics. For global topics, the English web wins.

Every query, cited URL and the language of each cited page are in the dataset (CSV/JSON, CC BY 4.0): https://tokensave.app/data/claude-web-search-by-language

How to Check Claude Code, Codex and Cursor Usage and Cost (2026)

Johmisking — Thu, 15 Oct 2026 12:13:58 +0000

Claude Code shows you how close you are to your plan limit, but not where the tokens went. Inside a session, /usage gives you a percentage bar for the 5-hour window and the week, and on the API it gives you an estimated dollar figure for the current session. What it does not give you is a simple history: how much did last Tuesday cost, which project ate most of the month, and was the Max plan actually worth it compared with paying per token?

That information is already on your computer. Claude Code writes every conversation to a log file, and each reply in that file records the model and the exact token counts. Command-line tools such as ccusage and CodeBurn read those files and add them up. I wanted the same answer without installing anything, so I built a Claude Code usage analyzer that reads the logs inside the browser. It also reads Codex logs and Cursor's usage export.

This post explains where the usage data lives, the ways to check it, and what I found when I ran my own logs through the analyzer. Every number below comes from those logs and from the official price lists, checked on October 15, 2026.

Where Claude Code stores your usage

Claude Code keeps a transcript of every session under ~/.claude/projects/. Each project gets its own folder, and each session is a .jsonl file: one JSON object per line. Subagent conversations sit in a subagents/ folder next to the session they belong to.

OS	Folder
Windows	`%USERPROFILE%\.claude\projects`
macOS	`~/.claude/projects`
Linux	`~/.claude/projects` (or `projects/` inside `CLAUDE_CONFIG_DIR` if you set it)

Every reply from the model has a usage block with five numbers that matter for cost:

input tokens: new input that was not cached
cache creation tokens: input written to the prompt cache, split into 5-minute and 1-hour writes
cache read tokens: input served from the cache
output tokens: what the model wrote, including thinking
model: for example claude-opus-5-5

Two details trip people up. First, the same reply is often written on several lines while it streams, and it can be copied again when you resume a session, so a naive sum counts it more than once. The analyzer keeps one copy per message ID and request ID. Second, the files do not live forever. According to the Claude Code documentation, it deletes transcripts older than cleanupPeriodDays, and the default is 30 days. If you want a longer history, raise that value in ~/.claude/settings.json before the old files disappear.

Four ways to check Claude Code usage

Method	What you see	Install	History by day and project	Plan vs API	Codex and Cursor
`/usage` inside Claude Code	Plan limit bars, current session, what counts against the limit	None	No	No	No
ccusage (`npx ccusage`)	Daily, monthly and session reports in the terminal	Node.js	Yes	No	Focused on Claude Code
CodeBurn (`npx codeburn`)	Terminal dashboard, many tools	Node.js	Yes	No	Yes, Cursor estimated
TokenSave usage analyzer	Cost by day, project, model and tool, CSV	None, runs in the browser	Yes	Yes	Yes

/usage is the right place to check whether you are about to hit a limit. On Pro and Max it also shows what is eating that limit, such as subagents, MCP servers or cache misses. It is not built for looking back over weeks. ccusage and CodeBurn are good if you already live in the terminal; both read the same .jsonl files. The browser analyzer is for people who would rather not install Node.js, or who want the plan-versus-API comparison on one screen.

How to use the analyzer

Open tokensave.app/claude-code-usage.
Click Choose folder and pick your projects folder. On Windows, paste %USERPROFILE%\.claude\projects into the address bar of the folder picker. On a Mac, press ⌘ + Shift + G and paste ~/.claude/projects.
Optional: add ~/.codex/sessions for Codex, and a Cursor usage CSV (Cursor dashboard → Usage → Export CSV).
Read the results. Switch the period between all, 7 days, 30 days and this month, and pick your plan to compare.

A few notes on reading the screen. "Replies" counts model responses after duplicates are removed, not your prompts; one prompt to an agent usually produces many replies, because each tool call and each step is a separate response. "Tokens" adds input, output and both kinds of cache traffic, so it will look enormous next to the size of your actual conversation. The project names come from the working folder recorded in each log, which is why the same repository can appear twice if you opened it from two different paths. If a model has no known price yet, the analyzer lists it under the tables instead of guessing, and the Download CSV button gives you one row per day with every token type and the cost, ready for a spreadsheet.

Chrome may ask "Upload files to this site?" when you pick a folder. That is the browser's fixed wording for folder access. The page reads the files with the browser's File API and only adds up numbers; your prompts and code never leave the tab, and nothing is sent to a server.

What my own logs showed

I loaded three sets of logs: the Claude agent sessions I used to build and maintain this site (they are written in the same Claude Code format), the Codex sessions on my PC, and the Cursor usage CSV from my account.

Tool	Replies	Tokens	API-equivalent cost	Plan I was on
Claude Code (Opus 5.5)	1,636	277.5M	$145.90	Max 5×
Codex (GPT-5.6 Terra, GPT-6 Luna)	108	6.5M	$1.98	Free
Cursor (Grok 4.6)	2	379K	$0.29	Free

The Claude Code part covers 10 active days between September 29 and October 15. The busiest day, October 8, came to about $39 at API prices.

The token split was the real surprise. Of 277.5 million tokens, only about 3,000 were fresh input. Around 264 million were cache reads, about 10.8 million were cache writes and 1.8 million were output. In other words, more than 95% of what Claude Code "used" was the same context being read again from the cache. That is how an agent works: on every step it re-sends the conversation, the files it opened and the tool results, and the cache makes that cheap.

Cheap is not free, though. Here is where the $145.90 went, priced at Opus 5.5 rates:

Part	Price per 1M tokens	Share of cost
Cache reads	$0.20	about 36%
5-minute cache writes	$5.00	about 34%
Output	$20.00	about 25%
1-hour cache writes	$8.00	about 4%
Fresh input	$4.00	under 1%

Cache reads are 95% cheaper than normal input on Opus 5.5, but there are so many of them that they still made up the largest share. Cache writes were almost as large, because every new file, tool result or long answer has to be written into the cache before it can be read cheaply. Output was only 1.8 million tokens, yet a quarter of the bill, because output costs $20 per million.

Without the cache, the same cache reads would have cost about $1,017 more at the plain input price. That is the "Saved by caching" figure in the screenshot.

Is Claude Max worth it? Plan vs API

The analyzer compares the plan you pick with the API cost of the same tool over the same period. My Claude logs span 17 days. Max 5× is $100 a month before VAT, so 17 days of it is about $56.67. The same tokens on the API would have cost $145.90, which means I used about 257% of the fee in API value. For heavy agent work, the subscription was clearly cheaper than paying per token.

Two cautions when you read your own result:

Plans have limits. Pro and Max reset every 5 hours and also have a weekly cap. If your API-equivalent figure is many times the fee, you are probably hitting those limits, and the real choice is between waiting, upgrading or paying for extra usage.
Light users can lose money on a plan. My Codex and Cursor usage was on free plans and came to $1.98 and $0.29. If I had paid for ChatGPT Plus ($20 a month) for that Codex usage, the plan would have been worth less than the fee. The analyzer shows this case in amber.

If you have never used Claude Code and want a forecast rather than a history, the Claude Code cost calculator estimates a month from task size and tasks per day.

Codex and Cursor usage

Codex keeps its logs in ~/.codex/sessions/YYYY/MM/DD/, one rollout-….jsonl file per session. Instead of one usage block per reply, it writes a running total for the whole session at each step. The analyzer takes the difference between steps and prices it at OpenAI's API rates, with cached input at the cached rate. In my files, GPT-5.6 Terra costs $2 per million input tokens, $0.20 cached and $12 output; GPT-6 Luna costs $0.10, $0.01 and $0.50. Archived sessions are moved to archived_sessions/ with the same name, so the analyzer counts a file name only once.

Cursor is different. I opened Cursor's local database on my PC, and every conversation had its token count stored as zero. Current builds simply do not keep token counts locally, which is why command-line tools can only estimate Cursor usage from text length. The accurate source is the usage export on the Cursor dashboard: go to Usage and click Export CSV. Each row has the date, model, input with and without cache writes, cache reads, output and the cost Cursor charged. The analyzer uses that cost as it is.

How to bring the number down

Knowing that most of the cost is cache traffic and output points to a few habits:

Start fresh sessions for new tasks. /clear drops the old context, so the next steps stop re-reading it. Long sessions keep paying cache reads on everything that came before.
Use Sonnet for routine work. Sonnet 5.5 is $2/$10 per million against Opus 5.5's $4/$20, so the same session costs about 50% less at API prices.
Watch the expensive days. The daily chart makes it easy to see which day, and so which kind of task, pushed the cost up.
Trim tools you do not use. On a plan, /usage shows which MCP servers and subagents take a share of your limit.

There are more ideas in ways to save tokens in Claude Code, and the limits themselves are covered in Claude Code usage limits.

FAQ

How do I see my Claude Code usage history?
Open your ~/.claude/projects folder with the usage analyzer, or run npx ccusage in a terminal. /usage inside Claude Code shows the current limits, not a history.

Does the analyzer upload my code?
No. It reads the files in your browser tab and only sums the token numbers. Nothing is sent anywhere.

Why is my API-equivalent cost so much higher than my plan?
Agents re-read the whole context on every step, which creates huge cache traffic. On a plan you pay a flat fee, so the API-equivalent figure is what the same tokens would cost if you paid per token.

Why does it only show the last month?
Claude Code deletes transcripts older than 30 days by default. Raise cleanupPeriodDays in settings.json to keep more.

Can it read Gemini CLI, Copilot or Windsurf?
Not yet. It reads Claude Code, Codex and the Cursor CSV today.

Summary

Claude Code already records every token you use; the hard part is reading it. /usage tells you how close you are to the limit, while the logs in ~/.claude/projects tell you where the money went. In my own 17 days of agent work, almost all tokens were cache reads, cache traffic made up about three quarters of the API-equivalent cost, and Max 5× returned about 257% of its fee. Codex and Cursor on free plans came to a couple of dollars. If you want to see your own numbers, load your folder into the usage analyzer and compare the result with your plan.

Sources

Originally published on tokensave.app. Try the usage analyzer with your own logs.

How to Make a Roblox Game in 2026: Step by Step with Roblox AI

Johmisking — Tue, 13 Oct 2026 07:15:34 +0000

Most guides on how to make a Roblox game start with "you don't need to know how to code," and then drop you into Roblox Studio, a window with dozens of buttons and no obvious first move. This guide follows one real first session instead. I installed Roblox Studio for the first time on Windows, made a block, got stuck putting a script in the wrong place, and then had Roblox's built-in AI build a disappearing stepping-stone course. Along the way I dropped in a free car from the Creator Store. Every screenshot is from that session. Anything that can change, like system requirements, publishing rules and payouts, was checked against Roblox's official documentation on October 13, 2026.

What you need to make a Roblox game

Roblox games are made in Roblox Studio, a free app. Roblox's official requirements:

	Minimum	Recommended
Operating system	Windows 10, macOS 10.14	Windows 11, macOS 14+
Memory (RAM)	3 GB	8 GB
Screen resolution	1600×900 or higher	1600×900 or higher
Price	Free	Free

You also need a Roblox account. Your normal player account works, and if you don't have one you can create it during setup. Studio runs only on Windows and Mac. If you want to make a game on a phone or iPad, see "Making a Roblox game on mobile" further down.

Step 1: Install Roblox Studio and sign in

On the Creator Hub (create.roblox.com), click Start Creating, then Download Studio.
Run the installer: RobloxStudioInstaller.exe on Windows, RobloxStudio.dmg on Mac. Windows shows a security prompt; check that the publisher is Roblox Corporation and click Run.
When the install finishes, Studio opens on a sign-in screen.

Click Log In and a browser opens. If you're new, choose Create account, then enter a birthday, username and password. The username field itself warns you not to use your real name.

After that you'll see a "Continue to Roblox Studio" screen and the Terms of Service. Accept them and Studio opens on its start page. It offers a guided tour, which you can skip.

Step 2: Pick a template

Click New Experience or Templates to see starting maps. My list had 15:

Type	Templates
Empty maps	Baseplate, Classic Baseplate, Flat Terrain
Game genres	Platformer, Laser Tag, FPS System, Racing, Classic Obby
Worlds	Village, Castle, Suburban, Pirate Island, Starting Place, Modern City
Other	UGC Homestore

For a first project, Baseplate is the easiest. It's just a floor and a SpawnLocation (where your character appears), so you can see exactly what you add. If you already know you want an obby or a racing game, starting from Classic Obby or Racing and editing it is faster.

Step 3: Add a block and change its color

The Studio window has four areas you'll use constantly:

3D viewport (center): your map. Hold the right mouse button and drag to turn the camera; move with W, A, S and D.
Home tab (top): Part, Move, Scale, Rotate, Color and Anchor.
Explorer (right): every object in the game as a tree. Anything under Workspace is physically in the map.
Properties (bottom right): values of the selected object, such as Color, Material and Transparency.

Click Part on the Home tab and a gray block appears. Click Color in Properties to open the color picker; I tried it on the SpawnLocation and turned it lime green. Click Anchor so the block can't roll or be pushed. Press the blue ▶ (Play) to test with your own character.

Step 4: Add a script, and where I got stuck

To make a block do something you need a script, written in Luau, Roblox's version of Lua. This one makes a block go see-through when a player steps on it, then disappear a second later:

local part = script.Parent
local touched = false

part.Touched:Connect(function(hit)
    if touched then return end
    local humanoid = hit.Parent:FindFirstChildOfClass("Humanoid")
    if humanoid then
        touched = true
        part.Transparency = 0.5
        task.wait(1)
        part:Destroy()
    end
end)

To add it, hover over your Part in the Explorer, click + → Script, delete the print("Hello world!") line in the editor and paste the code.

That sounds simple. It wasn't. I pressed Play, stepped on the block, and nothing happened. The Output window showed this in red:

Three things had gone wrong at once:

What you see	Why	Fix
`Touched is not a valid member of Workspace`	The script sits directly under Workspace, not inside the Part, so `script.Parent` is Workspace	Drag the Script onto the Part in the Explorer
Nothing runs at all	One stray character (`s`) pasted on the last line; a single typo stops the whole script	Delete it
Your fixes vanish	You edited while Play mode was running	Press the red ■ (Stop) first, then edit

The parent-child tree in the Explorer is the most confusing part for a beginner. On my next try the script landed under the Baseplate and the new blocks ended up nested under a Texture. At that point I switched to the easier route: Roblox's AI.

Step 5: Make the game with Roblox Assistant (AI)

Roblox Studio has a built-in AI called Assistant. According to Roblox's docs it answers questions, creates and edits objects and scripts, inserts Creator Store assets and generates 3D models. Click Assistant at the right end of the top bar and a chat panel opens.

You just describe what you want. I sent four requests:

"Make a red block, put it in front of the spawn point, and when a player steps on it make it go half-transparent and disappear after 1 second."
Edit: add a respawn so the block comes back after it disappears.
Make 10 of them in a line as stepping stones.
Edit: give all 10 the same behavior as the first block, including the respawn.

Each request took 15 to 30 seconds. The disappearing block I'd failed to wire up by hand came out right on the first request, with the script already inside the block.

After the third request Assistant summarized what it built: 3×1×3 pads, 4 studs apart so you can jump between them, ten in a row starting in front of the spawn, grouped in a folder called RedSteppingStones. Then it asked whether it should give the stepping stones the same disappear-and-respawn behavior.

After the fourth request the course worked as asked. Each stone turns see-through when you land on it, disappears a second later, and comes back three seconds after that.

By the screenshot timestamps, it took about 15 minutes from opening Assistant to running across all ten stones. That was less than the time I'd spent fighting with one script by hand.

How to write requests that work. Roblox's own Build guide says to be specific about how the game plays. A request like the first one above, with the color, position, trigger and timing in one sentence, needs fewer corrections than "make a fun obby."

Step 6: Save your game

There are two ways to save:

File → Save As: saves a .rbxl file on your computer. That's what I did.
File → Publish: uploads the game to Roblox's cloud and ties it to your account, so you can keep working from any computer. A published game is still private: only you and people with edit access can join until you release it.

Add a free car from the Creator Store

The Toolbox on the left searches the Creator Store, where people share models. Plenty are free and some are paid. I searched for a car, inserted the free "Drift Car mobile", and it drove straight away, speedometer included.

Models made by other people often come with scripts inside. After inserting one, look in the Explorer to see what came with it.

Is Roblox's AI free? Usage, API keys and MCP

Open the … menu at the top right of the Assistant panel to get to Assistant settings. It has four tabs: Usage, API key, MCP servers and Skills.

Usage. There is a free allowance bar. After all four requests above it read 6% used, resets in 6 days. You can switch on buying extra usage with Robux and set a daily spending cap. On my screen that switch was off and the cap field showed 500 Robux. Roblox's docs don't publish the exact size of the free allowance, so treat the 6% as a rough measure of what a small feature costs.

API key. The default model is "Roblox default" and follows a daily limit. You can instead plug in your own Anthropic (Claude), OpenAI or Google API key. Then you pay that company's API rates, and Studio warns that your data goes to that provider. To estimate what that costs, run your prompts through the token cost calculator.

MCP server. Turn on "Use Studio as MCP server" and an outside AI coding tool can drive your open Studio session. Per Roblox's docs it can read and edit scripts, run Luau code, start and stop playtests, move the character, simulate keyboard and mouse input and capture the viewport. Quick connect supports Antigravity, Codex CLI, Claude Code, Claude Desktop, Cursor, Gemini CLI and Visual Studio Code. My screen only listed the four I had installed. For costs, see Claude Code pricing and Codex pricing. How the tools compare on the same task is in Claude Code vs Codex vs Cursor.

Making a Roblox game on mobile: Build

Studio is desktop-only, but in July 2026 Roblox added Build to the mobile app. According to Roblox's docs, you describe a game in the Build tab and the AI generates gameplay, characters, environment, sound and achievements, and you can publish with one tap. For now it focuses on 2D and 2.5D games such as clickers, arcade games and side-scrollers. You get a set number of free prompts per day and can buy more with Robux.

Releasing your game and earning from it

I didn't release this test game, but here is what Roblox's docs require:

Release to ages 16+: your account must be at least 2 days old and you must complete an age check (facial age estimation or government ID). Answer the content-maturity question in the Publish window and the game goes live.
Release to all ages: everything above, plus verifying your account, turning on 2FA, and either 2 consecutive months of Roblox Plus or Premium or a refundable 1,000 Robux publishing fee. You get the fee back if the game keeps 25 highly engaged players for 60 days.
Earning: you earn Robux from passes, developer products, subscriptions, paid private servers and more, and turn it into money through the Developer Exchange (DevEx). The standard rate is $0.0038 per Robux, so 30,000 Robux = $114. You need to be at least 13 and have at least 30,000 earned Robux to cash out.

What it was actually like

With Assistant, a first-timer can go from installing Studio to a working disappearing stepping-stone course in a little over an hour. My honest take after the session:

To make a proper game, the free allowance probably isn't enough. The Assistant panel is narrower than I expected. It doesn't cover the game view, but it would have been nice to pop just the Assistant out into its own window. With free assets and templates, plus paid ones, there's a lot of variety, so building looks easy.

One small feature used 6% of the free allowance. A game with a full map, a shop and saved progress will likely need more than the free tier through Assistant alone. For bigger builds, plan on buying extra usage with Robux or connecting Claude Code or Codex over MCP.

How long will your game take, and what will it cost?

A stepping-stone course is a starting point. A real game's time and cost depend on genre and size. In the AI game cost calculator, choose Roblox as the platform and enter your genre and scope. It returns the expected build time, AI tool costs and a ready-to-paste kickoff prompt. If you don't have an idea yet, start from what's trending on Roblox right now. Real numbers from games I built solo with AI are in indie game development cost.

FAQ

Is it free to make a Roblox game?
Installing Studio, building and publishing to the cloud are free. Assistant has a free allowance; past it you buy more with Robux. Releasing to all ages requires a Plus or Premium subscription or a refundable 1,000 Robux fee.

Do I need to know how to code?
Not for simple games. The stepping-stone course here was built without writing a line of code, just by describing it to Assistant. Knowing how to read the Explorer tree (what sits inside what) saves a lot of time when something breaks.

Can I make a Roblox game on my phone or iPad?
Roblox Studio is Windows and Mac only. On a phone, the Build feature in the Roblox app makes 2D and 2.5D games with AI.

How do I show my game to friends before releasing it?
Use File → Invite early testers to invite up to 10 similar-aged friends to a preview.

Sources: Roblox Creator Hub, Studio setup, Create and publish games and places, Assistant for Studio, Connect to the Studio MCP server, Create games with Build and Developer Exchange, checked October 13, 2026. Screenshots taken October 13, 2026 on Windows 11.

Originally published on tokensave.app.

Claude Opus 5.5 Effort Levels Tested: Low to Max

Johmisking — Fri, 09 Oct 2026 11:06:54 +0000

I'm a solo developer in Korea who builds games with AI. Claude Opus 5.5 has five effort levels, so I ran the same prompt at every one of them and measured it.

Claude Opus 5.5 has an effort setting that controls how deeply it thinks, with five levels: low, medium, high, xhigh and max. Higher levels are supposed to give better results, but the official docs give no numbers for how much extra time and money each level costs. So on October 9, 2026 we ran the same game-building request once at each level and compared time, tokens, cost and the result. The fastest level took 32 seconds and the slowest took 22 minutes. Here is what changed at each level and which level to use for which task, along with hands-on experience.

What effort is

It sets how much the model thinks. Thinking can't be turned off on Opus 5.5; effort controls how deep it goes. Thinking tokens are billed as output tokens.
The default is medium. Opus 5 defaulted to high; Opus 5.5 defaults to one level lower, medium (per Anthropic's docs).
How to change it: in Claude Code use the --effort option (low to max); in the API set the effort value.

How we measured

Model: Claude Opus 5.5 in Claude Code on a Windows PC
Prompt (verbatim): "Make a brick-breaker game that runs in the browser as a single file named index.html in the current folder. It needs 2 levels, a score display and 3 lives, and it must be playable with the keyboard and the mouse. Write the file and finish."
Method: the same prompt five times, changing only effort. Each level ran in its own folder so runs could not affect each other.
Measurement: tokens and cost with the free tool ccusage, time from start and end timestamps. Cost is converted at API prices.

Results: time, tokens and cost

Effort	Time	Output tokens	Total tokens	Cost	Game code
low	32 s	3,368	129,315	$0.48	138 lines
medium (default)	52 s	6,299	133,428	$0.56	358 lines
high	1 min 50 s	12,376	222,854	$0.75	523 lines
xhigh	4 min 32 s	32,435	472,082	$1.36	639 lines
max	22 min 22 s	160,033	2,504,957	$5.25	1,121 lines

Low and medium are almost the same. Low cost 14% less and took 38% less time, but that is 8 cents.
High cost only 34% more than medium. Time went from 52 seconds to 1 minute 50 seconds.
xhigh is where costs jump. It cost 143% more than medium and took 4 minutes 32 seconds.
Max is in a league of its own. Medium took 52 seconds and $0.56; max took 22 minutes 22 seconds and $5.25. Output tokens went from 6,299 to 160,033.

The five games side by side

All five games ran without errors and met the request: 2 levels, score, 3 lives, keyboard and mouse controls. The differences are in what each level added on top.

Effort	What it added
low	Single-color bricks, the plainest screen, no pause
medium	Rainbow bricks, pause, restart
high	+ particle effects, saved best score
xhigh	Particle effects, more polished design (no saved best score)
max	+ sound effects, level names, an invader-shaped level 2, screen shake, victory fireworks

From high up, the model tried to check its own work. High and xhigh tried a code syntax check, and max tried an automated play test. All three needed permission to run, so none actually ran; each says it re-read the code instead. Low and medium finished without checking.
Bricks that take two hits appeared at every level even though we did not ask for them.

Level-by-level review

We played each game and checked it against the summary the model left at the end and the code itself.

low: 32 seconds, $0.48

What it built: level 1 is four rows of blue bricks; level 2 mixes orange bricks that take two hits with gaps, and the ball is faster. It has level-clear, game-over and win screens and a restart.
Good: every requested feature is there, and where the ball hits the paddle changes its angle. Done in 32 seconds.
Weak: black background and single-color bricks make it the plainest. No pause, and at 138 lines the shortest code.
Use it when: you just need to check that something works and will polish it later.

medium: 52 seconds, $0.56 (default)

What it built: level 1 is a 5×10 rainbow grid; level 2 has gaps and bricks that take 2 or 3 hits, showing hits left and fading as they take damage.
Good: pause (P or Esc), restart (Enter) and auto-pause when the window loses focus. Scoring depends on brick strength and level.
Weak: no sound or particle effects.
Use it when: most of the time. It costs 8 cents more than low and is a clear step up.

high: 1 minute 50 seconds, $0.75

What it built: level 2 is a diamond pattern of bricks that take 2 or 3 hits, and bricks throw particles when they break.
Good: a level-clear bonus, a bonus for lives left, a saved best score and touch controls. It also tried a syntax check on its own code.
Weak: it took 112% longer than medium (52 seconds to 1 minute 50 seconds).
Use it when: you need a prototype to show people or coding where quality matters. It cost only 34% more than medium.

xhigh: 4 minutes 32 seconds, $1.36

What it built: level 2 is a diamond ringed with steel bricks that crack after the first hit. Bricks are worth 10 to 50 points by color.
Good: the tidiest-looking screen, and mixing mouse and keyboard works smoothly: whichever you used last moves the paddle.
Weak: it dropped the saved best score and touch controls that high had. It cost 143% more than medium without adding features over high.
Use it when: not for small tasks like this. Per Anthropic, it suits long-running work.

max: 22 minutes 22 seconds, $5.25

What it built: named levels ("Rainbow Wall", "Space Invader"), an invader-shaped level 2 whose 14 silver bricks take two hits, and a narrower paddle on level 2.
Good: sound effects (M to toggle), saved best score, touch controls, screen shake, victory fireworks and auto-pause: the most of any level. It looks like a finished game.
Weak: by far the slowest, partly because it tried to run an automated play test that needed permission.
Use it when: quality matters most and you have time and limits to spare, or nothing else solves the problem.

Hands-on: medium day to day, high for coding

I use Opus 5.5 on the Claude Max 20x plan to build games. This is how it feels in daily use, not a measurement.

My setting: I leave effort on auto. It usually runs at medium and goes up to high when I'm coding.
low: it felt sluggish, so I used it a few times and stopped.
high: the results are clearly better.
xhigh and max: I tried them about once and rarely have a reason to use them.

Compared with the measurements, low was actually the fastest but gave the plainest result, so the sluggish feeling was about the output rather than speed. The sense that high gives better results, and that xhigh and max are rarely needed, matched the numbers.

What Anthropic recommends

Medium is strong. In Anthropic's testing, Opus 5.5 at medium matched or beat Opus 5 at high on coding and knowledge work.
Low comes close to medium on coding, at much lower cost, according to Anthropic. In our test the difference in output was noticeable.
Reserve xhigh and max for work where you've measured a quality gain.
Changing effort mid-conversation can break the prompt cache. In the API, use a per-message effort change to keep the cache.
Independent testing agrees. Artificial Analysis found Opus 5.5 at max effort used 63% more output tokens per task than Opus 5 (per press reports).

Which effort for which task

Our recommendations, combining the measurements, my experience and Anthropic's guidance:

Task	Recommended effort	Why
Simple edits, renaming, tidying files	low or medium	Fast and cheap, but low's output is plain
Everyday coding and new features	medium (default)	Usable results in 52 seconds for $0.56
Game or app prototypes, coding where quality matters	high	34% more cost for clearly better output
Runs over 30 minutes, big refactors	xhigh	Per Anthropic's guidance
Hard problems nothing else solves	max	Only when needed: time and cost jump

Start at medium. Move only the tasks where the result falls short up to high.
On a plan, think in limits. The higher the API-equivalent cost, the faster your Max or Pro limit drains. One max run used more than nine medium runs.
Caveat: one run per level on a fairly small task. Bigger projects may show different gaps.

Conclusion: medium by default, high when it matters

Default: medium. Usable results in 52 seconds for $0.56.
When quality matters: high. Only 34% more than medium for clearly better output. The best value of the five.
xhigh: skip it for small tasks. 143% more than medium but no more features than high. Worth it only for long runs.
max: only when you need it. The flashiest result, but 22 minutes and $5.25.
low: not recommended. Saving 8 cents over medium just gets you a plainer result.

FAQ

What is Opus 5.5's default effort?
Medium. Opus 5 defaulted to high. API requests that don't set effort run at medium on Opus 5.5.

Is max always better?
In our test it added the most features and polish, but took 22 minutes and $5.25 versus 52 seconds and $0.56 for medium. Too much for simple work.

Does low save a lot?
In our test low was only 14% cheaper than medium. Given the plainer result, medium is the better choice.

Calculate it for your own work

In the coding agent cost calculator, enter task size and tasks per day to see a month on Opus 5.5. Check a single prompt's cost in the token counter. For price and performance differences between Opus 5 and 5.5, see Claude Opus 5 vs 5.5.

Measured October 9, 2026. Cost is ccusage's conversion at API prices; results may change with model and Claude Code updates.

Sources

Originally published on tokensave.app.

3 Days to Build, 14 Days to Debug: The 14 Bugs I Fixed in My Vibe-Coded Game (Google Play Closed Testing)

Johmisking — Thu, 08 Oct 2026 10:27:25 +0000

In part 1 I made a game in 3 days with zero coding experience, just by describing it to an AI. I was ready to hit "publish" when Google Play stopped me: a new personal developer account has to run a closed test with at least 12 testers for 14 days before it can launch.

Fourteen days. More than four times longer than building the game. Instead of just waiting, I decided to play it every day. And I found out that without those 14 days, launch would have been a disaster.

3 days to build, 14 days to debug. This is the story of the 14 bugs I fixed, from building through the closed test to after launch.

What is Google Play's 14-day closed test?

If you created a personal Google Play developer account after November 13, 2023, you have to run a closed test before your app can go to production.

Testers: at least 12 people who opted in
Duration: those testers stay opted in for 14 days
Then: apply for production access from the Play Console dashboard

Organization accounts don't have this requirement. I found about 20 testers through test-for-test swaps with other indie developers. A lot of solo developers treat these 14 days as dead time. For me, they were the last chance to catch bugs before launch.

Sperm Race's code, by the numbers

I counted the code in the version files still on my computer (translation files excluded).

In the first two days I got 16 revisions from the AI, and the code doubled.
While turning it into an Android app, about 2,250 lines were added, and the "this used to be a bug" notes in the code went from 8 to 17.
From the first version to the latest, about 10,900 lines were added. That includes new features like Survival mode and Play with friends, not just bug fixes.

I didn't write a single one of those lines. All I did was play and describe what I saw. The code passed 8,000 lines, and a Claude Pro plan was still enough all the way to launch. If you want to know how many tokens your own code is, paste it into the Claude token counter.

"Find the bug" doesn't work

At first I just said "find the bug and fix it." The AI would confidently say "Fixed!", but the bug was still there, and something that used to work was now broken. It was like walking into a doctor's office and saying "fix whatever's wrong" without saying where it hurts.

What worked was saying which mode + what I did + what happened. Honestly, my own reports were vague at first too. The quoted bug titles below are what I actually typed (translated from Korean), and many of them, like "drag controls feel harder than before," leave out where and how.

Vague	Specific
"Find the bug and fix it"	"In racing, the lap counter jumps from 1/3 to 2/3 right after I cross the start line"
"Drag controls feel harder than before" (what I said)	"In racing, when I drag far to the side on a curve, it suddenly brakes"

Luckily, every time the AI fixed something it left a note in the code like "this used to cause a problem," so the bug history was all still there. The screens below were reproduced in the real game, either by running those old version files or by undoing just one fix. Bugs that would have broken the game or failed review are major bugs; the rest are minor bugs.

7 major bugs

1. One lap done before the race even started (while building)
In racing mode, the light went green, I moved one step, and the lap counter went up. To the game, the sperm parked just behind the start line looked like racers "about to finish a full lap." A 3-lap race was really a 2-lap race. Moving the grid in front of the line fixed it.

2. Cutting in for first place (while building)
In racing, finishing your laps opens a gate to the center, and the first sperm to touch the egg inside wins. But the gate opened for everyone as soon as anyone finished their laps. So I could sit at the start line, wait for an NPC to finish its laps, then slip through the gate and win. It worked the other way too: I'd finish my laps and head for the egg, and an NPC that had been wandering around the track would slip in and take first place.

So I asked for two rules: "a sperm that hasn't finished its laps can't go inside" and "you only finish by actually touching the egg." Both came from me getting annoyed while playing.

3. "Pressing the back button mid-game closes the app" (closed test)
I accidentally hit the phone's back button mid-race and the app just closed. A race I was winning, gone. If that had shipped, the first review would have been "back button closes the game, 1 star." Now it returns to the main menu during a game.

4. The sperm betting parlor (closed test)
During the test period I read through Google Play's policies and broke into a cold sweat. Derby mode said "odds" and asked "who will you back?" A game where you bet on racing sperm. To a reviewer, that looks exactly like a gambling app. I changed it to star ratings (★★★☆☆) and "who will you cheer for?"

5. Tap for free stuff (closed test)
A fake purchase button from development was still in the game. Tapping it charged nothing and instantly said "purchase complete." A fake ad gave the reward after waiting 5 seconds. Heaven for players, deceptive behavior to Google. I removed all of it.

6. The whole game froze (after launch)
I made it through the 14 days and launched. I thought I was done, but the scary part came next. I submitted the game to another platform and got rejected. The timer was stuck at 00.0s and the racing screen was black. All four modes.

The culprit was the gamepad. Sperm Race supports gamepads, so every frame it checks "is a gamepad connected?" On that platform, checking for a gamepad wasn't allowed at all. Every check threw an error, and every error froze the game. It never happened on my phone, no matter what I tried. A nice-to-have feature froze the entire game somewhere else.

7. Korean for everyone else (after launch)
Sperm Race supports 13 languages. But anyone whose phone language wasn't one of those 13 got the whole game in Korean. The culprit was written right there in an August 20 note: "If detection fails, default to Korean." A default I set while building it in 3 days came back as a bug a month later. Now unknown languages get English.

7 minor bugs

Not game-breaking, but you'd notice right away.

Endless spinning at the egg: On the last lap, NPC sperm kept spinning in front of the egg instead of going in. They turned too fast and kept bouncing out. Now they slow down for sharp turns.
Head here, tail there: When you hit an obstacle, the head bounced back but the tail stayed put, so the tail stuck out in front of the head.
"Game sound keeps playing in the background": Even with the app minimized or the screen off, the game sounds kept going. The sperm were still racing in my pocket.
The silent soundtrack: When the phone blocked the first attempt to play music, the game assumed "music is already playing" and never tried again.
"Drag controls feel harder than before": On curves, if my finger drifted down even a little, the game read it as braking, so every curve meant a sudden stop.
"The typhoon isn't working or I can't see it": The new obstacle only showed up from stage 29. I had never gotten that far. I moved it up to stage 12.
Zero isn't a number to the AI: A maze meant to have "0 rivals" had 3. The code read 0 as "no value" and filled in the default of 3. The cause was a single symbol.

How to use your 14-day closed test

If you're waiting out your closed test right now, here are three things you can take straight from my experience.

1. Report bugs to the AI with this template

[Mode/screen] Racing mode, Stadium track
[What I did] Pressed gas after the start signal and crossed the start line
[Expected] Lap stays at 1/3
[What happened] Lap jumped to 2/3 immediately
[Every time?] Every time
[Device] Android app (phone model)
After fixing it, leave a comment in the code explaining why it happened.

Keep that last line. My AI left a "this used to cause a problem" note every time it fixed something, so I could always look back at what was changed and why. Those notes are how I was able to write this post.

2. A checklist for the 14 days

I wrote this so it works for any mobile game, whatever the genre. In brackets are the bugs I actually hit.

Things your phone does

Press back in the middle of a game (the app just closed)
Minimize the app, turn the screen off, and come back mid-game. Does the sound stop? Does the game resume? (sound kept playing)
Check the sound works right after first launch, before you tap anything, and after your first tap (music never started)
Try other phones and screen ratios. Ask your testers

Saving

Change settings and progress, then fully close and reopen the app. Is everything still there?

Language

Set your phone to a language your game doesn't support and launch it (Korean for everyone else)
For each supported language, check text doesn't overflow its buttons

Play to the end, and cheat

Play to the last stage. If that takes too long, ask the AI for a test-only skip (the stage-29 typhoon)
Try to cheat the win condition: stand still, go backwards, steal what someone else set up (cutting in for first)
Put 0 or the maximum into number settings: 0 enemies, 0 seconds, max level (0 rivals, 3 showed up)

Store policy

Look for words like "odds," "bet," or "wager" that could make the game look like gambling (the betting parlor)
Remove any fake purchases, fake ads, and test buttons from development (tap for free stuff)

Features that might be unavailable

Have the AI check that the game keeps running when optional features like gamepads, vibration or notifications are blocked (the whole game froze)

3. Two safeguards for bugs you can't see

After launch, bugs show up on devices, languages and platforms you've never seen. Sperm Race now has these two. You can ask the AI for them like this:

Bug report button: "Add a bug report button to the settings screen. When someone reports, send the game version, device info and the most recent error along with it." To quote the note the AI left: "With the version, the device and the last error together, you can usually narrow down the cause on the spot."
A no-freeze safety net: "If an error happens while drawing a frame, don't let the whole game stop, and log the error. For optional features like gamepads, just skip them quietly if they don't work."

The 14-day closed test felt like a chore at first. Now I'm grateful for it.

Try Sperm Race

Sperm Race is free on Google Play. If you run into a bug, please tap the bug report button on the settings screen. Those reports are my favorite thing to get.

Google Play: Sperm Race
Web version (itch.io): Sperm Race

Curious what an AI-made game costs in money and time? Plug your genre and size into the AI game cost calculator. And put bug-fixing time in your schedule. For me, it took more than four times as long as building.

How did you use your closed test? Any bugs that only showed up on someone else's phone?

A Beginner Vibe-Codes a Game — Zero Coding, 3 Days, $45

Johmisking — Mon, 05 Oct 2026 12:37:15 +0000

I had zero coding experience. I didn't even know what a "game engine" was. Still, by describing what I wanted to an AI in plain words, I made a game in 3 days, and getting it to launch cost $45.

This is part 1 of the dev log for Sperm Race, a silly sperm-racing game.

Google Play: Sperm Race
Web version (itch.io): Sperm Race — it came out on itch.io first, then on Google Play.

"Let's make an easy game" took me all the way back to sperm

My goal at the start was simple: "Just make an easy game."

But the more I thought about what "easy" means, the more primal my ideas got. A game with one rule. A game that needs no explanation. A game everyone already knows. Following that line all the way back, I ended up at sperm. Swim forward, reach the egg, done. When you think about it, it's the one race every one of us has already won once.

The moment that thought hit me, I laughed out loud. "Wait, this is funny."

That one reaction set the direction. Not a serious game, but a goofy one that makes you smirk the second you see it.

I didn't know what a game engine was

I had never written code. I didn't know engines like Unity or Godot existed, let alone what they do.

So I started without one. I told Claude (Sonnet) in Korean, "I want to make a game like this," and what came back was a single HTML file that ran right in the browser. Later I wrapped that same file into an Android app and put it on Google Play. Building by describing what you want to an AI instead of writing code yourself has a name now: vibe coding. Looking back, starting without knowing anything was actually faster. No engine to install, nothing to study, and I could play it on day one.

The first prompt: "I want to make a game where a sperm swims to meet the egg"

That one sentence produced the first version. A sperm appeared on screen, and I could move it with my finger.

The problem was the tail. It was stiff as a stick, more matchstick than sperm. So the second thing I said was:

"Add a wave to the tail."

On the left is the stiff tail from the first version; on the right is the next version with the wave. Just making the tail wiggle finally made it look like a living sperm. That's how the main character was born.

Three days of adding, cutting and adding again

After that I couldn't stop. Every time I played a build, the next idea showed up. If it came to mind, I added it. If it didn't work, I cut it. Then I added again.

"Make a map." Now there was somewhere to swim.
"Add obstacles too." Once there was something to dodge, it became a game. This is today's Adventure mode.
"Add sperm racing, like real car racing." A Racing mode with 3 laps around a track.
"Make a mode where they run on their own like horse racing, and I place obstacles." Pick a sperm to root for and help it win with obstacles. This is Derby mode.
"Make a survival mode where you run away, with cancer as the motif." Dodge cancer cells in a maze and survive for 1 minute 30 seconds.

The file dates left in my Downloads folder show how fast it went. I got the first HTML file in the early hours of August 19, and by the next afternoon I had downloaded a new version 16 times. That's "fix this → download the new file → play" four or five times every half day. Meanwhile the code grew from 47 KB to 149 KB. By August 21 I was already taking screenshots for the store.

Graphics and sound effects, all in code

There isn't a single image file in this game. The character, backgrounds, tracks and mazes were all drawn in code by Sonnet.

From left: Adventure, Racing, Derby, Survival. The sperm is one ellipse and a wiggling line, the track is a thick curve, and the maze is glowing straight lines. For a silly game, that simplicity actually worked.

Same with sound effects. There are no sound files; Sonnet synthesized the sounds in code. The only audio file in the game folder is free background music from Pixabay.

The testers' first reaction: "That's so original"

Before launch I showed it to testers. What came back was: "That's so original."

The idea that started with "wait, this is funny" wasn't funny only to me.

Here's what was in the game at launch:

4 modes: Adventure (120 stages), Racing (3 laps), Derby, Survival (last 1 minute 30 seconds)
13 languages
Controls: drag, arrow keys/WASD, gamepad

Multiplayer with friends (up to 10 players in Derby, 4 in the other modes) came later, in an update after launch.

So what did it cost? $45

Item	What I used	Cost
Code	Claude Pro subscription (Sonnet)	$20 (one month)
Graphics	Drawn in code	$0
Background music	Free tracks from Pixabay	$0
Sound effects	Made in code	$0
Launch	Google Play developer registration	$25 (one-time)
Total		$45

I use Claude Max 20× now, but Sperm Race was built entirely on the Pro plan. It was done within a month, so I only paid for one month.

For comparison, if you run a small game through the AI game cost calculator, the standard stack (image and music AI plus Claude Max) comes out at $128–181. Sperm Race came in at about 25–35% of that.

Next time

So far it looks like "AI made a game in 3 days, easy." But the real struggle came after. Building took 3 days; fixing bugs took 14.

Next: 3 days to build, 14 days to fix bugs — why AI pokes at the wrong code when you ask it to "find the bug," and how I ended up finding bugs myself and having the AI fix them.

Originally published at tokensave.app.