We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
TS Rust: pick the right reference, set a measurable goal, then work on the environment
Theo released TS Rust, a rewrite of the TypeScript compiler, type checker and LSP in Rust, published as a real npm package. He says agents worked on it for five months. About $400k of Codex tokens got nowhere, then about $20k of Opus 5.5 finished it in two weeks. He says he hasn't read a single line of the code . His benchmarks put it at 12.5x faster than TypeScript v6 and about 2x faster than Microsoft's Go-based TSGO. He notes that Bun's bun check Rust rewrite is faster still .
Three lessons are reusable:
- Start from the easiest source to port, not the original. Opus didn't translate the JavaScript. It ported Microsoft's Go version line by line, including a port of Go's standard library and goroutine runtime. Theo says GPT-5.6 Sol and Astra struggled with the direct JS-to-Rust route .
-
Make the end state numeric. The first build was 2–3x slower than Go. Before the change, the agent kept declaring success after reaching full compatibility plus one performance win. The fix was a
/goalof "minimum 2x faster than the go build. Continue iterating until we get there," and it ran for two weeks . -
Your job is the environment. His prompts were short: read
AGENTS.mdand the accountability/audit files, keep multiple workflows and subagents running in parallel, and "I trust your judgment fully" . The real work happened elsewhere. He fixed OS-level out-of-memory crashes that were knocking his effort setting down to medium, and he gave the agent SSH access to two spare VPSs when it ran short of compute. Separate audit threads tracked blockers and recurring failure modes so agents stopped stepping on each other .
On cost, he estimates about $24k at full API prices, or roughly 925–983% of one account's weekly limit spread across six Claude subscriptions. With a free reset, he puts the effective cost at about $500 .
Golden oracles and verifiable loops
Geoffrey Huntley writes up a conversation with Justin Cormack that applies the same idea to infrastructure. Cormack had an agent write mkfs.xfs in Rust with byte-for-byte identical output and every flag supported. It reverse-engineered the on-disk formats one at a time, with tests across block sizes, in a few hours. The recipe: treat the original tool as the oracle, generate output with both at different sizes, diff them, port the tests, and automate it . Huntley also used a loop to port Go's Stripe library to OCaml for a unikernel . When Cormack had an agent prototype an OS, it put the tests in Nix flakes. NixOS machine tests can spin up a fleet to check network rules against the app .
On language choice, Huntley says OCaml's .mli interface files are "really efficient context" for agents and that its compiles are fast. Compile time limits a loop's throughput: four agents building Cormack's roughly million-line Rust S3 clone compete for disk and CPU, so "you end up spending more on fast machines than on tokens" .
Matthew Berman is running the same loop on Super Mario World for the Mod Retro. GPT-6.1 Sol writes code, compares the result with what the game should look like, and iterates. It has been going for more than four days, and he expects a few more . He points to /goal and /loop in Claude Code, Codex and Cursor as the way to set this up .
Coordinators that delegate
Riley Brown's starter prompt for Claude Code Projects asks the agent to rank work by importance, scan your email, Slack and other connections for possible threads and automations, and run an "Organizer" thread that keeps an editable to-do list . He keeps the coordinator in the cloud on Opus 5.5 so it is always available. Some threads run locally on a MacBook and two always-on Mac minis, and routine threads use Haiku or Sonnet . His website project has grown to more than 35 threads. He talks to the coordinator from his phone, and it routes each request to the right named thread . Grok bot's "primary bot" works the same way: asked to polish dark mode and open a PR, it passed the task to a dev agent . SpaceX says Grok bot will now send hard tasks to other backend models, including Opus 5.5 .
Kent C. Dodds merged 104 PRs in one day and published the GitHub search so others can judge the work . By bedtime he was at 110, with six agents still running, and he hadn't opened his computer that day . He credits Grok bot as a major part of the workflow . His biggest friction now is GitHub notification email . Huntley says he recreated Gitpod in under 10 days and plans an open-source, on-prem release . He now provisions workloads on it through Grok bot from his phone . His disclosures say SpaceXSI comps his Grok bot usage .
Steer, don't queue
Theo argues that modern models can absorb a mid-task "steer" message without getting distracted, so he doesn't queue messages . T3 Code lets you change the default . Kent says Grok bot doesn't support queueing at all, and it copes when he interrupts with unrelated tasks. He guesses that it delegates everything to subagents . Codex steering is now immediate. Brown notes that steers used to wait for the next tool call, which could waste tokens first .
Does fan-out pay?
- Vals AI ran GPT-6 Sol and Opus 5.5 on Vibe Code Bench, both alone and as teams. Teams cost 1.8–5.1x more. Only Sol at medium effort improved significantly, by 7.3 points, delegating in parallel along architectural lines. Opus ran sequential waves of about 6.8 subagents with no significant gain .
- LangChain says sending each Open SWE task to the cheapest model that can handle it cut median cost per task by 64% .
-
Claude Managed Agents dynamic workflows are in public beta (
multiagent_20261001). They fan out to as many as 1,000 agents per run, and Anthropic advises starting with scoped tasks because token use can be high . - Claude Max and Team now include monthly API credits: $100 for Max 5x, $200 for Max 20x, and up to $500 pooled for Team. They work on any model, in your own code or third-party harnesses .
- An AI agent built a Rust XFS formatter in a few hours, reverse-engineering the on-disk formats and flags and testing different block sizes; Huntley recommends using the existing formatter as a golden oracle and comparing outputs across sizes while porting its tests.
- For a missing library in a niche environment, Huntley suggests looping an LLM to port an implementation across languages—for example, Go to OCaml for Stripe support in a unikernel. In a Nix OS prototype, an agent built tests into flakes; Nix machine tests can create a fleet to test network rules and an application.
- Compile speed can limit agent-loop throughput: slow Rust builds make each hallucination more costly, and four agents compiling a roughly million-line Rust S3 clone competed for CPU and disk.
- In a Claude Sonnet 3.5 experiment to create the language Cursed, which Huntley said was broken on GitHub, he found that putting a grammar and lexical-structure lookup table in context could help a model build a language without it being in the training data; he described this as brute-force and inefficient, and said fine-tuning was unnecessary.
-
For behavior-preserving ports, use a known implementation as an oracle: an AI agent recreated
mkfs.xfsin Rust, matching its output bytes and flags while reverse-engineering disk formats and testing block sizes; the work took a few hours. Run the original tool to generate reference outputs, then port and automate its tests to verify the replacement. - A one-week AI-assisted OCaml/Mirage exploration used an NTP client from another language as a starting point, then built NTP client/server support and a reusable time library using multiple clock sources; the wider library set included HTTP/API clients and servers, structured logging, and retry/back-pressure utilities.
- AI agents handled a Nix-based OS prototype whose tests were built into flakes; Nix machine tests can spin up fleets to check network rules and application behavior. Local overlays were presented as a faster way to patch dependencies than waiting on upstream maintainers.
- Treat compile speed and shared build resources as agent-throughput constraints: slow Rust builds make hallucination fixes costly and reduce attempts per minute, while four agents compiling an roughly million-line Rust S3 clone competed for disk and CPU.
- Theo says Opus 5.5 completed his TypeScript compiler/checker/LSP rewrite in Rust. Rather than translating JavaScript directly, the agent ported Microsoft’s Go rewrite; Theo says earlier models struggled with the direct JavaScript-to-Rust path. The first Rust build was 2–3× slower than Go, so he set a minimum 2× speedup target and let the agent iterate for two weeks. He reports the result is about 2× faster than TSGO and 12.5× faster than TypeScript 6 in his comparisons.
-
His reusable workflow centered on setup and orchestration, not elaborate prompts: he had agents read
AGENTS.mdand type-check/accountability files containing audit notes, set explicit compatibility and performance goals, and keep multiple independent workflows running in parallel. When the work ran out of compute, he fixed OS-level issues and added SSH access to two VPSs; separate audit threads tracked blockers and recurring failures so he could improve the environment and keep agents from interfering with one another. He describes his role as manager-like: removing bottlenecks and equipping the agents rather than writing the code himself.
- A useful coding-agent pattern is a verifiable loop: define an observable target, let the agent write code, compare its behavior or output with a reference, and iterate; where possible, split work into chunks and run agents in parallel. A reconstruction may reproduce behavior without recovering the original source code.
- For his Super Mario World recreation for Mod Retro, Matthew Berman assigned GPT6.1 Soul to rebuild the game from scratch; the agent consulted online documentation and repeatedly checked its implementation against how the game should look. After more than four days of work, he estimated it might take a few more days.
-
Berman points to
/goalor/loopworkflows in Claude Code and Cursor: give the agent a high-level goal and have it continue working toward completion.
- LangChain reports that routing each Open SWE task to the cheapest adequate model cut median cost per task by 64%; the rationale is that many agent steps are yes/no calls rather than generation.
- Claude Managed Agents’ public beta lets a lead agent create a phased plan, fan tasks out to as many as 1,000 agents per run, then merge results; Anthropic advises starting with scoped tasks because token use can be high. Claude Code Projects support parallel task threads and local sessions. Devin also supports trees of managed Devin agents, so wall time tracks the slowest branch rather than the sum of branches.
- A Vals AI Vibe Code Bench comparison found agent teams cost 1.8–5.1× more; only GPT-6 Sol at medium effort improved significantly (+7.3 points). Opus 5.5 used sequential waves—about 6.8 subagents and 1,140 subagent tool calls per app at max effort—with no significant gain.
- Codex’s new Windows sandbox, built on Microsoft Execution Containers, offers faster setup, network enforcement, and granular file controls.
-
For agent-led reimplementations, use the original program as a golden oracle: an agent wrote
mkfs.xfsin Rust to match the original byte-for-byte and support every flag, reverse-engineering disk formats incrementally and testing across block sizes. Diff both implementations’ outputs, port the tests, and automate the checks; this took a few hours. - Geoffrey Huntley used a loop to port a Go Stripe library to OCaml, making Stripe available in a unikernel.
- In an agent-prototyped OS, tests were built into Nix flakes; NixOS machine tests can exercise application behavior across a fleet and its network rules, while overlays provide a way to handle broken upstream dependencies.
- Huntley built the Cursed language with Sonnet 3.5 and 3.7, a deliberately underspecified prompt, and three months of running the work in a loop. He moved from C—where weak feedback led to wasted time in Valgrind—to Rust, then Zig, which he calls a mistake; he estimates the effort at roughly US$6,000 and says he did it three times over.
-
For agent coding, Huntley favors OCaml’s
.mlityped module interfaces as efficient context and notes its fast compile times; Rust agents are capable too, but slow compilation can reduce iteration speed, and four concurrent Rust builds caused disk/CPU contention.
- Kent reported a personal record of 104 PRs merged in one day and said a forthcoming YouTube video would explain his process; he described the work as valuable.
- He credited @poteto and the team’s work on @bot as a major part of his workflow. At bedtime, he said six more agents were still working, although he had not opened his computer that day because of church meetings and a long play practice.
- He identified the volume of GitHub emails as his biggest friction and considered turning off GitHub email notifications.
- Riley Brown uses Claude Projects to maintain his website: a coordinator routes requests to named threads, and his project has grown to more than 35 threads. He sends requests from his phone; cloud threads can run with his computer off, while local threads can be controlled from his phone when the computer is on.
- In the demonstrated Grockbot team-bot setup, the bot connects to Slack and supports shared plugins and skills; its primary bot delegates a dark-mode polish request to a development agent rather than starting the work itself.
- Codex’s immediate steering lets users change a prompt while the agent is working; Brown says this avoids waiting for another tool call and can prevent wasted tokens before the agent reads the correction.
Claude Max and Team plans now include monthly Claude Platform API credits: Max 5x gets $100, Max 20x gets $200, and Team gets up to $500 pooled. The credits work with any model, including Haiku 5.5, in code or third-party harnesses, and can support building apps and agents through the API, Managed Agents, or Agent SDK.
- Engineers can build an edge through sustained hands-on work with agents, whose benefits compound; teams catching up should experiment ambitiously and share what they learn rather than keeping it private or relegating it to after-hours work.
- Senior engineers should lead the shift, applying their system-design and failure-mode experience to improve how teams build with agents, then sharing effective practices for others to replicate.
- For website maintenance, Brown uses Claude Projects as a coordinator over 35+ threads: he sends a request to the coordinator, which routes it to a named thread. From his phone, cloud threads can run while his computer is off, and local threads can be controlled when it is on.
- In Grokbot, a Slack-connected team bot can share plugins and skills; its primary bot delegates work. When Brown asked it to polish Native Note’s dark mode and make a PR, it handed the task to the Native Note dev agent.
- Codex’s immediate steering lets a user change the request while the agent is working; Brown says the previous delay until the next tool call could waste tokens before the agent read the correction.
- Brown reports that Grokbot can route harder tasks from Grok 4.7 to Claude Opus 5.5, selecting a backend model for the task.
- Claude’s model selector includes Haiku 5.5; Brown suggests using it for many tasks on the $20/month plan to conserve tokens as smaller models improve.
A transferable software-agent design lesson is to keep the learned model’s role focused and use failures and human corrections from real deployments to address edge cases, prioritizing targeted data over dataset size; Jentoft says an in-situ edge-case fix can take only a few dozen examples. In Standard Bots’ machine-tending example, the model locates and identifies parts while conventional programming handles motion and cell logic—a concrete division between learned behavior and deterministic code.
Kent C. Dodds says interest in Kody validates what he is building and signals a team-focused direction; he links to Kody’s business page . The linked practitioner example describes an open-source, self-hostable layer for personal agents that separates authentication, enables auditing and fine-grained permissions, and lets users switch agent apps; its builders say they gave Instinct the same tools as Claude Code on a laptop .
Kent C. Dodds identifies the coding-agent pattern of copying a Slack task into Claude, waiting, then pasting the PR link back as “product engineering” territory—and says he shifted to teaching it earlier that year. The quoted post cautions that simply moving prompts between windows is not enough, arguing engineers should be product-first or foundational rather than stuck in the middle.
Kent C. Dodds says Grok, his “main driver for everything,” does not let him queue messages; he gives it multiple tasks and interrupts it, including with unrelated subjects, and reports that it figures them out. He guesses this may work because Grok delegates to subagents, but presents that as speculation.
Kent C. Dodds recommended checking out Kody for developers uncomfortable letting an agent see and use their tokens . He was responding to shadcn, who shared that concern and said they had not found a solution .
Geoffrey Huntley’s disclosures list Namespace Labs as comping CI/CD and SpaceXSI as comping @bot usage; they also list OpenAI Holdings. This is useful context when weighing his later tool or coding-agent recommendations, though the post itself gives no workflow or tool evaluation.
Geoffrey Huntley says he rebuilt Gitpod in just under 10 days and plans to make the recreation open source and available on users’ own infrastructure. It is integrated with @bot, which lets him provision platform workloads and tasks from his phone.
Geoffrey Huntley says he recreated his former employer Gitpod in just under 10 days; he says an open-source version that runs on-premises and on users’ own infrastructure is coming soon.
- Riley recommends creating a Claude Code Project as a personal agent hub, prompting it to prioritize tasks, review connections such as email and Slack for useful threads or automations, and maintain an editable todo list and key documents; he suggests giving one thread the role of “Organizer.”
- Projects separates a coordinator chat from delegatable subagent threads, which can run in the cloud or locally. Riley keeps the coordinator in the cloud for availability and runs some threads on a MacBook and two always-on Mac minis; he suggests Opus 5.5 for the coordinator and Haiku or Sonnet for routine tasks.