We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
Fable 5.2: cheaper tokens, similar cost per task, and effort settings that changed
The release. Cursor added Claude Fable 5.2 right away.
- CursorBench: 56.9% at default effort, up from 49.2% for Fable 5.1. At max effort it scores 60%, the top result on that benchmark .
- Price: $8/M input and $40/M output tokens, 20% less than 5.1 .
- Speed: Addy Osmani says it generates output up to 30% faster than 5.1 .
Watch the per-task cost. Osmani says Fable 5.2 "uses a lot of tokens". In their testing, a task costs roughly the same as on Fable 5.1 despite the lower price . Theo's numbers on the $200 Claude Ultra plan point the same way. He estimates the plan covers about $15,000 of Opus 5.5 a month but only about $3,000 of Fable. Fable is also capped at 50% of the weekly limit and "burns faster per $" .
Theo's preferred measure is work done per week:
- Opus only: about 1,200 turns and 230 threads.
- Fable until its limit, then Opus: about 900 turns but slightly more threads. He says Fable is more likely to finish work in one prompt .
He based this on more than 1.1 million real API requests . He warns the numbers may shift, because much of his usage so far has been benchmarking the new model .
Don't reuse your old effort setting. Cursor says effort levels behave differently from 5.1. Start at the default and compare levels at cursor.com/evals . Theo reports that on the code-only benchmarks in Slopalytics, xhigh and max score worse than high. Fable's overall 5-point lead also shrinks a lot on code benchmarks . Alex Albert gives similar advice: start at medium or high and save xhigh for the hardest problems .
Prompt tip: tell it the code is its own. Anthropic's Fable 5.2 prompting guide, quoted by Simon Willison, says the model adds to existing structure, even repeating code, unless told the code is its own. The suggested sentence is: This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it. On small coding tasks, it merged repeated code in about half of tries with this sentence and under a tenth without it .
Alex Albert's workflow tips :
- Before it builds anything, ask it what's wrong with your idea. It will push back.
- Say up front what needs your approval, such as deletions, and that the rest is its call.
- Give it a whole project rather than the next step, and let it run for hours.
He also runs one audit prompt on every project whenever a new model arrives: "Read this entire project and find everything that's broken, inconsistent, inefficient, or no longer needed. Fix what you're sure about and list the rest for me to review."
Fable or Opus 5.5? Most early advice says to keep Opus as the default.
- Osmani: start most coding work on Opus 5.5 and use Fable for ambitious, open-ended work .
- @TheWholeDaisy: use Opus when you already know what you want, and Fable for creative tasks where you don't .
- Theo's 3D-game test: Fable took 76 minutes and about $42. He rated it "not significantly better than Opus 5.5 (esp. for the price)" . The Opus version had a better gameplay loop, controls and performance, and he thinks the two models will work well together on 3D-game tasks .
Simon Willison: let the agent see and change the running app
To find a beep among unopened boxes, Willison built Beep Locator (repo). It located the source to within about 40 cm: a carbon monoxide detector that needed new batteries .
His steps:
- Start from a spec. In Claude Code Cloud on his iPhone (Opus 5.5, Extra effort), with an empty repo, his first prompt was "Write out a problem.md file describing the problem." Claude found and read a 2007 paper on acoustic ranging while writing the spec .
- Ask for hot-reload, not just the feature. He told it to "add a mechanism so you can send new code to the listeners which they will then run automatically", so it could keep experimenting while he did something else .
-
Iterate live. On his laptop, Claude Code with Fable 5.2 started the server, could see what was happening, and could change the software as it ran. An
installModule()hook pushed code to the listening devices over WebSockets. That avoided page reloads, which on some devices re-trigger microphone permission prompts .
Handing routine work to agents
Pi issue triage. The Pi team was sorting 30–100 issues a day by hand. They built an issue-triage bot on Pi Durable. Sub-agents trigger on each new issue, do a first analysis and a first fix, and a maintainer approves the diff . A small classification guide updates as humans sign off on processed issues. They say the bot now matches their taste using past examples, which probably wouldn't have worked six months ago .
Kent C. Dodds' state-machine prompt: "Find all of the implicit state machines in my app… elevate… UX, DX, and agent experience (AX)… without breaking anything. Also, make state machines explicit."
Romain Huet (OpenAI) says skills or AGENTS.md files untouched for about four months are "probably far outdated" .
Running agents on other machines
- Dots (OpenAI): you can now connect several local computers to one dot and choose which handles a task. For example, it can build and test on a dedicated machine while you keep coding on your laptop .
- T3 Code: press cmd+k and search "mcp" to set up a connector for any agent you want to control T3 Code from . Theo's tip if you hit Grok Bot usage limits: get the $100 Claude plan, install T3 Code, set up that connector, and tell Grok Bot to "call T3 Code with Opus 5.5 for any task where it is applicable" .
- Brendan Long's sandbox: he runs Claude Code with all permission prompts disabled (clawed-abode) . To contain the risk, agents run as an unprivileged user inside an unprivileged VM. They use rootless Podman instead of Docker, because Docker access easily gives root . They reach the GPU only through a queue over SSH into a gVisor + nvproxy container. Its allowlist of NVIDIA driver calls reduces exposure to driver exploits, though imperfectly .
- The Pi team replaced manual sorting of 30–100 issues a day with a Pi Durable bot that triggers on new issues, runs an initial analysis and fix, assigns a category/priority and a responsible human, and lets a maintainer check the diff for straightforward fixes. Its classification guide is updated from issues reviewed and signed off by a human; the speakers say newer models can now match their issue-selection preferences using past examples, a workflow they thought would not have worked six months earlier.
- For API or library design, have the agent generate scratch files and examples for each API slice, try them yourself, then get feedback from real or prospective stakeholders; their critique—not an agent’s reassurance—should drive the next iteration. A related personal-tool pattern is to add an in-app feedback button and have an agent process submissions and improve the app in the background, without requiring another chat prompt.
- Keep architecture judgment human-led: the discussion says agents still struggle with system design, especially distributed systems, and that even an AGENTS.md instruction did not prevent a one-off, unscalable engine change; prompting still affects whether the agent produces a mess.
-
Willison started Beep Locator in an empty GitHub repository using Claude Code Cloud on his iPhone with Opus 5.5 in Extra thinking effort mode. He first asked Claude to formalize the problem and proposed architecture in
problem.md; Claude found and read the BeepBeep research paper, then he asked it to build the system and support sending new code to listeners. -
For live iteration, he ran the server on his laptop with Claude Code and Fable 5.2, letting the agent observe and change the running app. An
installModule()feature let the server push new code to listener clients over WebSockets, avoiding page reloads that would prompt for microphone permission on some devices. - A reusable pattern is to give the agent a live, instrumented perception loop: browser listeners kept a 60-second audio buffer, detected candidate beeps with FFT and a high-pass filter, and reported them to the Python server; the server then triggered a chirp and requested clips from roughly 0.6 seconds before the beep to 0.8 seconds after the chirp to align recordings. Willison could query the audio logs and reconfigure the system while Claude worked on it; it located the source within about 40 cm.
- To test and debug the system, he asked for clap detection as a test signal, distinct map symbols, timestamps, and sequential playback of recordings from each listener—making it easier to match real-world sounds to logged clips and identify the mystery beep.
- Berman says he deliberately under-specifies some build prompts: a three-line request for a one-level Unreal Engine Gears of War clone matching the original’s graphics, gameplay, and characters produced a playable game in a few days; he ran it in Ultra Code mode.
- For a different from-scratch task, he constrained a realistic balloon-and-water simulation to one HTML file using JavaScript, CSS, and WebGL2, with no frameworks or external libraries, and specified adjustable parameters plus freeze and camera controls. He reports it took about 2.5 hours and 41 million tokens.
- For code review, he ran max thinking effort with Ultra Code, which fans out subagents, across his codebases; he says it surfaced bugs, security issues, and UI inconsistencies, and tasks he previously expected to take 60–120 minutes took at most 10 minutes. He cautions that Ultra Code is extremely expensive and does not recommend it generally.
- In his assessment, Fable 5.2 outperformed Opus 5.5, but Opus was faster and much less expensive. He gives Fable 5.2 pricing as $8 per million input tokens and $40 per million output tokens; its faster mode was listed at $16/$80 per million tokens for 2.5× speed.
- OpenAI merged the legacy ChatGPT.com codebase—described as millions of lines—with the newer ChatGPT/Codex desktop-app codebase and deployed the result in under a month, using models named “Astra” and “Ultraast” in the transcript. Huet said the effort would previously have seemed impossible and might have taken about a year; he credited the models with making it possible.
- Huet’s recipe for company-wide AI adoption is both a top-down mandate that gives teams freedom to change how they work and curious engineers experimenting from the bottom up. He specifically says teams may need to rethink engineering workflows, PR submission and review, and risk thresholds before production.
-
Keep agent instructions current: Huet warns that skills or
AGENTS.mdfiles untouched for roughly four months may already be outdated as frontier models improve. - Huet outlines a delegation workflow in which a proactive agent receives a reported Codex issue, starts a Codex task to inspect the codebase and investigate it, prepares a fix/PR, then returns it for review; the human can decide whether to request more input or merge.
-
Use a typed
{decision, reason, summary}output; requirereasonto name the policy used, route malformed results to a human, and allow the agent to abstain when uncertain. In one iteration, about 25% of cases were abstained on—including cases the agent should have approved; splitting policy selection and the final decision into two calls reduced abstains but raised cost. - Put deterministic rules before model calls to short-circuit mandatory human reviews, missing-data cases, and obvious approvals or denials; delegate remaining case parts to small subagents and combine their outputs with a synthesizer. Smaller components made failures easier to locate and parts easier to swap, but added model calls, cost, and latency; scheduling helped when users did not need an immediate response.
- For workflows that may wait days, save the graph’s position, interrupt, and resume it when a human or external signal arrives; keep case data separate from graph state when systems need cross-run SLA or aggregate queries. Airbnb chose LangGraph for system connections, data access and permissions, stop/replay, and inspection of individual runs—not primarily for its agent loop. Its trust agents accessed roughly 10 systems only through MCP, with no direct API or database access; access controls and logs made decisions traceable later.
- Treat offline evaluation and live-run verification as separate jobs: combine LLM judges with code checks, run code checks daily, and sample automatically decided cases for weekly LLM-judge review. A separate checker from a different model family compared answers to duplicate records and sent disagreements to a human, but identical wrong answers could pass—so it was used alongside other judges and checks.
- For support-agent training, Airbnb shifted from selecting the best-sounding generated draft to using the human agent’s actual reply; sound-based selection had allowed the assistant to drift from policy.
- Brown favors Claude Projects for task orchestration: set a project purpose, then use its persistent cloud coordinator to launch local or web task chats in parallel. He says he can message the coordinator from his phone, but local sessions require his laptop to be on; he reports using Projects on his phone to build desktop, iOS, and web apps and landing pages. He calls Projects simpler than competing agent products, while noting that access is limited and waitlists are frustrating.
- For model and API access, Brown describes giving Claude Code an AI-gateway key and asking it to turn the integration into a skill, so he can request different models through that interface; he says billing must be configured. He also describes Composio Instant as a router offering one key across services with usage-based billing.
- For video work, he wraps the Gemini API as a skill and uses it specifically to analyze video; he says Gemini considers video and audio together, while Claude analyzes frames and audio separately.
Sanfilippo’s main workflow advice is to calibrate trust: know when to hand the agent control and when to retain it, and use automated discovery loops with broad access when the task warrants it (he cites GPU discovery as an example). He cautions against mistaking elaborate setup for skill, mocking configurations with 200 MCP servers and 50 skills as needless overhead; he recommends using the model relatively “vanilla”—simply asking it to do the task—rather than assuming extensive scaffolding improves results.
A low-friction permission pattern for coding agents is safety-provisioned auto mode: avoid approval prompts every few seconds, minimize workflow interruptions, and retain prompts for important actions.
A Handshake frontier-data episode demonstrated two agent/model-evaluation cases: whether a model that knows a tax rule can identify where to apply it in Python valuation code, and tracing an agent’s activity through files read, copies checked, and shell history cleared.
Simon Willison looked up Yonkers on Google Maps, then tested Claude Fable 5.2 Medium’s 3D modeling and animation by prompting it to make a Three.js animation using OpenStreetMap data, with Yonkers standing up as a mech and stomping around Manhattan, Queens, and Brooklyn. The model correctly interpreted his keyboard typo “átomos” as “stomps.”
For Claude Fable 5.2, explicitly frame the codebase as the model’s own to encourage structural cleanup rather than adding to existing structure, which it may do even when that duplicates code: “This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.” In Anthropic’s small-coding-task tests, the model merged repeated code in about half of attempts with that sentence, versus under a tenth without it.
- Before running software supplied during an interview, ThePrimeTime recommends asking an AI agent to check whether it sends data off the computer, saves or changes files, or installs anything; this is framed as advice, not a guarantee that an agent will catch every threat.
- The video’s account of the Binance incident says an attacker used engineer B’s compromised computer and an internal AI tool as a springboard to gain control of wallet DevOps engineer A and software engineer C; it gives no further detail about the AI tool’s role.
Anthropic introduced Claude Fable 5.2 and Claude Mythos 5.2, claiming improvements in coding, reasoning, and vision for ambitious technical work. ThePrimeagen responded with a quip about “make reconnecting websockets, no mistake,” putting a concrete coding task alongside the broad capability pitch.
For Claude Fable 5.2, try telling it “This codebase is yours” when asking it to improve existing code: Anthropic says this can encourage the model to merge duplicated code and make related fixes. In its small coding-task tests, it merged repeated code in about half of attempts with that sentence, versus under one tenth without it; results varied by task.
- Claude Fable 5.2 generates output up to 30% faster than Fable 5.1 and is positioned for ambitious, open-ended technical work; Osmani recommends starting most coding and knowledge tasks with Opus 5.5 instead. Fable 5.2 is available on paid Claude Platform plans and major cloud platforms.
- Osmani cautions that Fable 5.2 uses many tokens: in their testing, its per-task cost was roughly the same as Fable 5.1 despite 20% lower token pricing.
Swyx highlights scratchpads as a way to make both humans and LLMs “a lot more powerful,” pointing to a post titled “Writing as a thinking tool”; for coding-agent work, this suggests keeping written working notes available to both developer and model.
Simon Willison framed an intermittent-beep problem as a vibe-coding task: build software to triangulate the sound using two laptops, two iPads, and a phone listening at once, rather than opening boxes methodically. The post gives no implementation or outcome details.
Anthropic’s Fable 5.2 launch work reportedly coordinated a team of 1,000 agents, within stated safety boundaries, on the long-horizon task of formalizing a proof of Fermat’s Last Theorem. The post presents this as a demo; it gives no implementation or workflow details developers could directly reuse.
Simon Willison hides most AI-generated GitHub PR-description text inside collapsed <details><summary> markup, supported by GitHub Markdown, to make the descriptions less exhausting to read. Swyx’s reusable shortcut is to bind the markup to a text expander (detsum); he also suggests expanding closing tags and frequently used inclusions or checklists, noting that deleting an auto-expanded block can be easier than typing it.
Claude introduced Claude Fable 5.2 and Claude Mythos 5.2 for demanding technical challenges, citing improvements in coding, reasoning, and vision.