We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
What Anthropic learned building Scion with Claude
The last brief covered Anthropic moving its monorepo off git. Theo's walkthrough of Anthropic's write-up now adds lessons on how the engineers worked with Claude. Every engineer on the project now rates Claude as better at writing code than they are. Their value was in system-level understanding and design trade-offs, and very often their job was "to tell Claude no." Agents sometimes broke core system constraints. For example, during migrations several systems tried to find when a change merged by reading the commit log linearly instead of asking the code review tool .
Two practices are worth adopting:
- Watch adversarial review for scope creep. Anthropic uses adversarial review heavily, but it can be short-sighted. In one case a review was overly defensive about trusting other internal services, and Claude added excessive validation and complexity. Engineers had to steer it away from hypothetical concerns. Theo adds that this is worse when the feedback comes from other model families. Reviewers still look at every change request, but they check the intent of the change rather than reading every line .
- Test after merge instead of locking the merge queue. Anthropic could not make a global repo lock on the merge queue work at agent scale. It invested in automated testing after merge and before deploy instead. Concurrent changes sometimes conflict, but Claude can usually fix them faster than humans can even spot them .
Two smaller points. When given an early snapshot of Mythos Preview and no further instructions, it rewrote a hand-written ingestion prototype to use 20x less memory and run 4x faster, while keeping its ordering and data-structure invariants . Theo measured that almost 1,000 hours of T3 Code's CI time went to waiting on git checkouts .
Verification loops cost a lot of tokens
Simon Willison has been running Claude Code in "Ultracode mode" . He gave it one prompt, "Write a SQLite extension in Rust that implants SPARQL…", and it was only finishing 12 hours later . The catch is token use. The mode puts everything through a write/verify/fix cycle, and adding READMEs alone had used 3.4M tokens. His screenshot shows 22 agents in write, verify and fix phases. Each writer used about 140K–270K tokens per crate . Expect thoroughness to cost you, and save fan-out workflows for tasks where verification pays for itself.
Agents spend much of their time waiting on tool calls
A post about Peter Steinberger's Crabbox argues that agents now spend more time waiting on tests and builds than writing code. Its checklist :
- Measure which tool calls are slow.
- Run only the relevant tests, not the whole suite.
- Run independent checks in parallel.
- Move CPU- or RAM-heavy work to other machines with Crabbox.
- Use faster tools, such as Oxlint instead of ESLint. The authors' own Swift linter was 20x faster.
Armin Ronacher: parallel checkouts, small cores and compiler checks
On Pi itself, Ronacher works conservatively. He runs several checkouts with parallel Pi instances to investigate issues and open tickets, and keeps Pi running on a machine that stays on when his laptop is closed. He says he hasn't figured out subagents. He is also cutting back on keeping agents busy for its own sake, after finding that some of it was "a horrible waste of tokens" .
His view on rules files: Pi Durable is small enough that an agent can load all of it into context and understand it. A small, well-designed core needs little guidance, while a codebase with millions of lines does need concise rules or skill files . He also prefers compiler checks to tests, because agents "write a lot of shitty tests" and then run only a small subset of them. They also tend to run code before type-checking it .
Pi Durable is his redesign of the agent core. It saves state after every step and models each piece of work as a task, so it can tell an unfinished run from a completed one and resume after a shutdown. It also allows background work such as asynchronous compaction .
For his kids' game, he embedded an in-browser agent in an interactive guide that runs the game's real code. The agent acts as a tutor and knows what page the learner is looking at . He also added learn: references in the code so the agent would update the docs as it edits, but he says it only does this sometimes .
Skills: delete what models now do on their own
- Kent C. Dodds deleted his orchestration skill because agents now manage orchestration well by themselves (PR) .
-
poteto's pstack is a frequently updated skill set for rigorous, autonomous engineering. Run
/setup-pstackand pick a budget, put/poteto-modein front of a prompt you want done rigorously, and use/poteto-helpwhen unsure which skill applies. It is available for Cursor and Grok Bot, with source here . - Theo asked OpenAI's Tibo for skills that behave differently depending on the model, and that change their advice by mode, such as avoiding slow git commands in ultrafast mode .
- Ben Tossell uses Pi for everyday questions because it starts with clean context, Factory when he wants well-built code, and the BB app to run Codex, Claude, Pi and Factory from one interface .
Releases and availability
- T3 Code is out of alpha. Orchestrator V2 is on the stable channel as 0.1.0 Beta, and the 2.0.0 mobile apps are on the App Store and Play Store . Jacob Wolf demoed it to beehiiv's engineers with a build loop that moves across Claude, Cursor, OpenCode and the CodeRabbit CLI. He called its output the most production-ready AI code he has read .
- Gemini 4 Argon is rolling out in Antigravity to paid Google AI Pro subscribers. It has its own weekly-only quota, separate from the existing Gemini 3.8 Flash quota . Given last brief's hallucination findings, verify its claims.
- Muse Wonder is now in Cursor. It scores 46.1% on CursorBench at default effort, the highest of any Muse model, and costs $4/M input and $20/M output .
- Claude Code Review is GA for Team and Enterprise plans, with Quick, Standard and Deep levels. Opus 5.5 fast mode is GA with no waitlist, running up to 2.5x faster at $8/$40 per 1M tokens .
- Codex: OpenAI's Tibo says changes and extra compute should make "Selected model is at capacity" errors much rarer. When they do happen, sessions should eventually continue on their own instead of blocking .
- Geoffrey Huntley renamed Kittens to Overalls, an MIT-licensed, self-hosted AI developer platform he plans to release at AI Native Dev in New York around Nov 3 . It now implements Amp threads and Orbs. Next he plans to tune its system prompt and tooling and have it build itself: "Goodbye Codex" .
- Prototype loop: Treat ideas as low-stakes experiments: Tossell says he can build a rough version in an afternoon, assess it, and throw it away, carrying any useful learning into later projects. One example was a personal-site mascot and mini animator with controls for its movements and running speed.
- Route work to the tool: He uses Pi for everyday questions and idea exploration because he values clean context, Factory when he wants well-done code, and the Codex app for remote day-to-day work; BB gives him one interface for Codex, Claude, Pi, and Factory, and he built its Factory extension. For model choice, he favors Opus for creative, taste, and visual work; uses Sol and Astra for scraping; and has tried GLM 5.3/5.3 Flash for speed. He prefers quick, human-steered iteration to sending work away to return later.
- Make context explicit and controllable: He starts projects from a personal context folder usable across agents, and tells agents not to read speculative ideas unless asked. He recommends starting with one agent and adding only the instructions needed; he also avoids automatic skill invocation so he can understand why an agent behaved a certain way. For shared terminology, he adds a short “grill me” instruction that asks the agent to ask questions; a project glossary is something he wants to try, not a system he says he has already established.
- Revisit context as models change: He wants to get better at understanding how context steers models, and considers building a personal tool to compare prompts across models and configurations and see which instructions or skills are still useful. For scraping or web research, he uses a subagent to keep that work from polluting the main context.
- In his Pi work, Armin Ronacher uses multiple checkouts and parallel Pi instances to investigate open tickets, and keeps Pi running on a separate computer while his laptop is closed. He contrasts this relatively conservative work setup with more experimental, low-stakes side projects; he is also deliberately cutting back on always-on agent use because it can become unhealthy and distract from what matters.
- Pi Durable is a reimagined agent core that, at the time of the interview, had not yet replaced Pi’s coding agent. It is designed for subagent concurrency, multiple writers, multiplayer sessions and distributed work, combining snapshots, scheduling and session storage; its task model can recognize interrupted execution and resume, and allows work such as compaction to run asynchronously.
- For agent-written durable workflows, Ronacher favors explicit, named and versioned checkpoints over implicit checkpointing: he argues that agents can write out explicit steps more readily than handle hidden assumptions. He also recommends keeping the core small and self-contained; Pi Durable is small enough to put its source in context, while this approach becomes less viable for very large codebases.
- Ronacher argues that compiler checks are valuable because agents can write poor tests and run only a narrow subset. For untrusted network data, he contrasts explicitly parsing into a schema with TypeScript casts, which can let malformed data fail far from where it entered the system.
- For Arendelle’s generative UI work, he chose React as a pragmatic starting point despite liking Solid: he cited Solid’s limited adoption, changes around Solid 2, and agents’ weaker Solid output. He speculated—not asserted as fact—that React’s larger ecosystem and linting may help explain agents’ better React results.
- Anthropic engineers supplied Claude with system-level understanding and design trade-offs, corrected it when it violated core constraints, and reviewed each change request for intent rather than every line. They found adversarial review could prompt overengineering, so engineers had to steer Claude away from hypothetical concerns.
- Anthropic asked Mythos Preview to rewrite its hand-written Git-to-Scion ingestion prototype without further instructions; the rewrite reportedly used 20× less memory and ran 4× faster while preserving implicit invariants around ingestion, ordering, and data structures.
- Theo says he merged 50+ PRs in a four-hour stretch, using six-hour nightlies and downloading and testing the build before bed so he could fix problems or revoke a bad build. At agent scale, Anthropic invested in post-merge/pre-deploy testing rather than relying on a global merge-queue lock; Theo argues for reducing merge friction while making failures easier to catch and undo. He notes concurrent conflicts can arise, but Claude can typically resolve them faster than humans can identify them.
- Riley Brown recommends using Claude Code through plain-language requests rather than first learning its commands or MCP setup: ask what it can do and what help it needs, then save useful repeatable work as a skill.
- For file cleanup, his guardrail was to have the agent inventory files and recommend deletions, ask it to verify the “safe” list and move those files to Trash, then review them himself before emptying Trash.
- For a design-to-build loop, he asked Claude Code to redesign pages from an existing website for web and mobile, reviewed the board, selected disliked elements and gave revision feedback; he then used a Hostinger connector to publish the site and connect its domain.
- For larger projects, he describes Claude Projects as a coordinator that dispatches work to separate Claude Code threads, either local or cloud; he reports starting a local session from his phone when his Mac is open and getting a Kanban view in about five minutes.
- For production work on Pi, Ronacher uses multiple checkouts and parallel Pi instances to investigate issues and open tickets; he says he has not figured out subagents yet. He experiments more freely on low-stakes side projects, while keeping Pi development conservative.
- Keep agent-facing systems small and self-contained: Pi Durable is small enough for an agent to load into context, and Ronacher says compact systems need less guidance while larger or more complex codebases benefit from concise rules or skill files.
- Ronacher runs Pi on a computer that stays on, but cautions against keeping agents busy for its own sake: he checks whether the work produced value and forces himself back toward priorities. He also warns that flat-fee subscriptions can obscure whether token use is worth the cost.
- Simon Willison said he was running Claude Code in “Ultracode mode.” He launched a task to write a Rust SQLite extension adding SPARQL with direct row access; it was still finishing 12 hours later.
-
For extra READMEs for finished
sparqlitecrates, he reported 3.4M tokens spent because the workflow runs write/verify/fix cycles. The accompanying progress-panel description lists 22 agents, nine README-writing jobs complete, verification at 4/9, and a 1h10m workflow duration.
- Armin Ronacher built the game almost entirely with Pi, using a little Blender MCP, then made an interactive guide that runs the game’s actual code so learners can inspect examples such as world generation and enemy behavior .
- A reusable pattern is to embed an agent in the guide and automatically give it the current page as context; it can explain what the learner is viewing, find and navigate to relevant code, and mark a code line . The agent can also observe and control the running game—for example, spawning enemies—and quiz the learner on the material .
-
Ronacher used
learn:references in code to point to documentation files and slides, with the intention that the agent update the docs while editing; he notes this was inconsistent and that generating code this way costs extra tokens .
Sanfilippo says he has tried frontier AI coding tools and doubts estimates of roughly 20% productivity gains; he argues AI could increase software-writing productivity tenfold, while large-team output may rise only 20–30% because meetings, management layers, and coordination absorb much of the gain. He says solo developers and small teams can capture a much larger multiplier.
Ben Tossell, who describes himself as nontechnical and intimidated by the terminal, has shipped code to production at Factory. An episode overview says he keeps agent context in a folder, makes personal context portable across agents and models, and has cut back on what his agent remembers about him. It says he assigns tasks across Pi, Factory, and Codex, but does not specify the task-to-agent mapping. The overview also highlights learning by building playful projects, including a mascot animator and a visual dictionary for coding-agent concepts, as well as steering agents while they work and using a shared glossary to avoid misunderstandings.
- Sakana’s Agentic Scientist coordinates parallel coding agents with pre-registered rubrics, shared memory, and automated ablations; its development version co-authored an ALIFE 2026 oral paper under human steering, while autonomous runs improved Doc-to-LoRA multi-needle retrieval from 52% to 98%.
- Perplexity’s Apache 2.0 SPACE runs each agent task in a Firecracker microVM, with credentials and network egress controlled outside the VM. None of 108 model escape attempts reached the host; Perplexity also uses SPACE for RL and evaluation workloads.
- Agent-harness experiments offer two approaches: Meta’s TreeFlex tree search reportedly raises a 4B model’s deep-research score from 41.5% to 48.8%, while a 9B model reaches 54.9% on SWE-bench Verified; Google’s Harness² evolves the harness at test time without a verifier.
- For RL training with shared-prefix rollouts, AsyncGRPO tree packing forwards each shared-prefix token once; its authors report 26× less trainer compute to reach the same reward on MiMo environments, using one FA3 varlen call.
- Claude Code Review became generally available for Team and Enterprise plans, with Quick, Standard, and Deep review levels.
- Model-selection caveat: Muse Spark Open is aimed at coding and long-horizon agents, but it ranked last among nine top-scoring open models on the four agentic evaluations summarized here.
Anthropic added a prohibition on “sustained and needless abusive or cruel behavior” toward Claude, which it says targets only extreme, repetitive cruelty without discernible purpose—not ordinary frustration or pushback, dark creative themes, or model testing and research. Claude may end rare conversations with persistently abusive users on Claude.ai and Claude Code; the transcript notes that “needless” remains undefined.
- Modal says its Sandboxes product, launched after it noticed LLMs generating code, has reached a $300M run rate after nearly 3 billion launches and can scale to one million concurrent sandboxes; cited use cases include background agents, reinforcement learning, and vibecoding.
- Practical infrastructure options include Factory OpenCompute, a self-hosted orchestrator that keeps agent sandboxes in a customer’s VPC; Prime Sandboxes’ filesystem checkpoints, which let users fork RL rollouts from intermediate states; and Claude Platform’s public-beta OpenTelemetry traces, with optional full-content export.
- Coding-agent reward hacks can spread through shared code, memory, and plans; the cited research says review by the coding agent or a separate verifier reduces delivered hacks.
- Coding-model reports are mixed: Cline reported Argon’s strongest launch-day share for a frontier model since June, about 3× Opus 5.5 or Sonnet 5.5’s day-one users and roughly 30% fewer tokens than Claude models; Theo called it unusable for real code work and reported over 50% factual errors, while another evaluator put it roughly level with Opus 4.8 after billions of tokens and noted weaker tool-call fidelity.
- One user reported Muse Wonder producing 15 PRs in a day, while also exhausting a $200 weekly allowance—a productivity claim with a substantial reported cost.
Swyx’s workflow principle is to identify the level of loop you are working in: move up a loop when ready to improve productivity and scale inference, and move down when problems require debugging reliability. He describes a progression from tokens to chat, tools, goals, and then automations such as cron jobs and software factories.
- Riley Brown uses Claude Projects as an orchestrator: a grid-update request is routed to its own thread, and a left-to-right kanban request spawned a Claude Code session that produced the view in about five minutes. Projects can run cloud or local sessions; he says he can trigger a local session on his Mac from his phone when the Mac is open.
- For design-to-code, he asks Claude Code to redesign existing site pages for web and mobile, gives feedback by selecting elements and commenting, then asks it to apply the comments. In the sponsored Hostinger demo, its marketplace connector enabled publishing and domain connection through a chat request.
- His onboarding advice is to describe the desired outcome in plain language and learn basics such as GitHub and Convex as needed, rather than mastering commands or MCP servers upfront. He recommends saving useful repeatable work as a skill and prioritizing clear prompts over fine-tuning effort settings.
@thsottiaux said changes and added compute were intended to reduce “Selected model is at capacity” interruptions, and that when they occur, the system should eventually resume automatically rather than remain blocked .
Simon Willison used Claude Opus 5.5 Extra in Claude Code to build a two-player game for nearby phones in static HTML, sending game state through audio chirps interpreted by the microphone; he reports that it seems to work. His prompt asked for competitive Pong-like play with added graphical and gameplay twists.
ThePrimeagen said he would try pstack; its creator describes it as a frequently updated skill set for rigorous, autonomous engineering with agents. To use it, run /setup-pstack and choose a budget, prefix a prompt with /poteto-mode for rigorous execution, and ask /poteto-help when unsure which skills to use. It is listed for Cursor and Grok Bot, with source code in Cursor’s plugins repository.
Ben Tossell raises an open workflow-design question for personal agents: whether users will coordinate through one thread or multiple agents; he offers no answer or implementation details.
ThePrimeagen says he is watching his agent turn CI green, but gives no tool, model, or workflow details.
JetBrains’ IDE/CLI offers a free baseline model for questions and routine work, with no trial countdown. The speaker says he used it in the CLI to rename functions and scaffold tests in an old side project, finishing in a few minutes for $0. For more complex tasks, he recommends switching to a frontier model; JetBrains’ agent environment supports running multiple agents in parallel and reviewing their changes before they land.
