We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
🔥 TOP SIGNAL
The bottleneck is now verification, not generation. Dominik Tornow’s blunt thesis is that recent models can emit code, but code verification—including testing—is still unsolved; he calls the verification harness “the software factory.” Theo reports the operational failure mode when capacity outruns feedback: unlimited tokens make teams ship faster while expanding bugs, regressions, and jank if developers do not use the product as changes land.
The artifact-level warning is just as concrete: @mitsuhiko says Astra produces “weird Python slop” one step removed from normal code and “absolutely horrific” unit tests. Treat agent-generated tests as untrusted inputs to an independent acceptance loop, not as proof that the change works.
⚡ TRY THIS
Build an independent acceptance loop. After each agent batch, run the normal test suite, then exercise a small set of real user flows yourself before accepting the result. That directly addresses Tornow’s verification gap and Theo’s warning that products deteriorate when developers stop using them while AI-driven changes land.
Make the repository survivable by a fresh thread. Theo says every new agent thread is effectively a fresh developer because the previous thread’s knowledge disappears. For unfamiliar or abandoned code, trace one flow end to end and branch outward carefully; for rewrites, isolate one chunk at a time instead of replacing the system wholesale. In a behavior-parity migration, use the concrete steering pattern: “here’s how it works in the other place; mirror that here.” Theo says this let him guide a roughly 60,000-line SwiftUI implementation from observed failures and the analogous system’s behavior without reading every implementation detail.
Do the work once manually, then earn the skill. Kent C. Dodds recommends doing a process “the hard way” before building automation so you do not optimize the wrong thing; he separately says to stop making agent skills after one good turn. Run the task across repeated cases, record failure modes, then codify the stable pattern.
Treat Fable limits as scheduling constraints. Theo reports that one five-hour limit can consume about 40% of a weekly allowance, while launching a long prompt with one hour left can consume roughly 60% of the weekly quota; his follow-up math says 22% of a five-hour allowance used about 9% of the weekly pool. Reserve long-running work for bounded jobs and watch both meters.
📡 WHAT SHIPPED
GPT-6 Astra effort and usage tuning. @thsottiaux reports that Astra on low reasoning effort performs better than GPT-5.6 Sol on high, and recommends moving former high-effort Sol workloads to Astra low or medium. A separate Astra usage update claims unchanged quality with up to 3–4× less subscription usage on long-tail workloads. Treat both as operator guidance and a usage claim, not an independent benchmark.
Omarchy + Muse CLI. DHH says
muse cliis now wired into Omarchy as both the default agent action and a lazy-loaded integration; the implementation is in Omarchy PR #9915.Cross-model video analysis as a reusable agent skill. AgentNative’s skill post says Codex with GPT-6 Astra can delegate full-video analysis to Gemini, and that the same skill works with Claude and GrokBot with a Gemini API key. Riley Brown says editors run it before editing and report roughly a 2× faster process; that performance figure is community-reported. Skill post
Isolated remote agents via Depot. In a sponsor segment, Theo describes setting up a Docker image and running
depot Claudeinstead of Claude directly to obtain an isolated sandbox; Depot’s shared cache is described as reusable across the developer, CI, and team. The sponsor claims up to 40× faster real-world Docker builds.
🎬 GO DEEPER
- Theo — “Stop Pretending You Understand Your Codebase.” Focus on the fresh-thread model and the behavior-first rewrite: the useful unit of context is architecture, data flow, and observed failure cases—not total implementation recall.
- First Light C — an AI that plays Clash Royale. Borrow the evaluation loop rather than the game: a local simulator feeds state to the model, executes its action, and returns the next state; imitation learning bootstraps the policy before reinforcement learning. A headline 80.1% win rate turned out to exploit one mostly inactive opponent, so the creator inspected replays and tested varied opponents instead of trusting the metric.
Editorial take: The practical edge is shifting from generating more code to surviving fresh context, real product use, and adversarial verification.
Direct answer: The strongest clip candidates are the fresh-thread context reset, partial-understanding rule, end-to-end ramp-up, chunked rewrite technique, and isolated-agent execution example. Timestamp status: The supplied bundle contains no explicit [mm:ss] timestamps or player-time metadata; use the video URL (https://www.youtube.com/watch?v=5KvY8CnBB3w) plus the transcript line ranges below as provisional clip locators.
- Context reset — highest-priority clip: Each new agent thread loses the previous thread’s work, effectively creating a fresh developer; the workflow implication is to configure the agent to operate effectively without historical knowledge.
- Partial understanding before local changes: In a large codebase, partial understanding is acceptable, but the agent or developer should understand how the pieces fit together before changing an isolated section.
- Ramp-up workflow for unfamiliar or abandoned code: Build understanding by tracing one flow end to end, then branch outward gradually while making careful changes. The transcript also recommends using AI to ask questions and verify its responses as a way to accelerate ramp-up, while recognizing that it lacks the prior team’s historical knowledge.
- Rewrite technique: A successful rewrite should carve the existing system into small isolated chunks and rewrite one chunk at a time, changing the old system incrementally rather than replacing it wholesale. The speaker adds that teams should first work in the existing codebase long enough to learn what works, what does not, and how to contribute meaningfully before attempting the rewrite.
- Isolated agent execution: In the sponsor segment, the proposed setup is to provide a Docker image through the CLI and run
depot Claudeinstead of invoking Claude directly, producing a real isolated sandbox for agent work. - Practical isolated-agent example: During a React Native-to-SwiftUI rewrite, the speaker says he had not read the mobile implementation but steered the agent using observed failure cases and the corresponding behavior in the other system. Overall knowledge of data flow, sources, and failure cases was more useful than reading every implementation detail; project selection for new threads is identified as an unusual failure area.
- Secondhand signal from Simon Willison: He points to an OpenAI report for details on how OpenAI researchers are using coding agents, rather than describing his own workflow. The attached chart’s alt text labels daily spend per researcher and describes growth from near $0 in February 2026 to roughly $600 by late August, after a ~$150–165 plateau into July.
- Willison asks whether the “huge uptick” in token spend in mid-July coincided with Astra becoming available to employees; this is an unconfirmed hypothesis, not an established causal explanation. The linked resource is the OpenAI research-acceleration report.
- Firsthand closed-loop agent training: The creator built First Light C, an autonomous Clash Royale agent that observes game state, chooses an action, executes it through a locally reverse-engineered battle engine, and receives the updated state; the project’s code, dataset, and model weights are public for reproduction or continued training. The simulator ran at over 10,000 ticks per second versus 20 ticks per second in real time, used batched GPU decisions across battles, and produced over 10,000 hours of simulated experience within a few hours.
- Structured state plus learned memory: The architecture combines a transformer for object relationships with a CNN for precise spatial layout, groups units from the same deployment to avoid an exploding object list, and uses an AOSTM memory module that updates from scene/map data, time, events, elixir, and prior actions. The creator explicitly avoided hard-coded card-tracking rules, letting training learn which history mattered.
- Bootstrap before reinforcement learning, then test for reward hacking: The creator first trained on 240,000 human matches via imitation learning, then used reinforcement learning with rewards including match outcome, tower-health changes, and wasted elixir because learning from scratch was too slow and compute-intensive. A model that reached an apparent 80.1% win rate was exploiting one fixed, mostly inactive opponent; the corrective practice was to inspect replays, verify that opponents behave normally, understand the winning strategy, and evaluate against varied opponents rather than trusting a single headline metric.
- Partial understanding is a viable agent workflow. Theo argues that large codebases require developers to understand architecture, component boundaries, and likely locations rather than every implementation detail. He says this reflects his experience with codebases containing hundreds of millions of lines at Twitch or Amazon, and that compilers, type checkers, linters, and AI can offload tedious checks as long as overall understanding does not decline.
- Design for context resets. Theo describes each new agent thread as a fresh developer because the previous thread's knowledge is gone; repository setup and workflows therefore need to let a capable newcomer act without historical context. For legacy code, he says AI can accelerate ramp-up by answering questions and verifying its understanding, using prior developers' outputs even when their historical knowledge is unavailable.
- Behavior-first rewrite workflow (firsthand). While rewriting the T3 Code mobile app from React Native to SwiftUI, Theo says he had not read a single line of the roughly 60,000-line Swift implementation. He steered the work using observed failure cases and his understanding of how the analogous system works, often instructing it: “here’s how it works in the other place; mirror that here.” He reports that only one or two bugs resisted this approach; project selection for new threads was one example of an unusual failure.
- Incremental legacy-change pattern. Theo recommends working in the existing codebase first to learn what works, what does not, and how the team operates; when rewriting, isolate and replace one chunk at a time rather than starting from scratch. For abandoned systems, he endorses understanding one end-to-end flow, then branching outward through careful changes.
- Isolated agent execution. In a sponsor segment, Theo says that after configuring the Depot CLI and a Docker image, developers can run
depot Claudeinstead of Claude directly to obtain an isolated remote-agent sandbox. Depot's shared cache is described as reusable across the developer, CI, and team, while the sponsor claims up to 40× faster real-world Docker builds.
- The panel’s contrarian coding-agent takeaway is that, as AI makes it possible to “program in English,” high-level language fluency becomes less differentiating; durable low-level knowledge of performance and computer behavior may matter more when abstractions or generated code fail. They caution that this is not a substitute for system design: low-level expertise will not by itself fix architectural problems such as excessive microservice request fan-out.
- For reviewing AI-assisted code, prioritize durable concepts over transient language and library knowledge. The panel specifically names caches, SIMD, virtual memory, threading, atomics, and memory management as concepts that remain useful across hardware generations; C or Rust are presented as convenient scaffolds for extending from ordinary code into those concerns. One panelist’s firsthand experience was that understanding how computers work enabled them to recognize inherently slow code by inspection, regardless of the language. Python itself was not treated as the mistake—the concern was omitting this lower-level foundation.
- Reusable video-analysis skill for coding agents: Riley Brown reports that AgentNative packages Gemini’s ability to watch and analyze full 30-minute videos in seconds into a skill for Codex. The linked
@agentnative_post describes Codex with GPT 6 Astra as the target, says the skill also works with Claude and GrokBot, and requires only a Gemini API key. AgentNative editors run the skill before editing, which Brown says makes the process approximately 2× faster. Full skill post: https://x.com/agentnative_/status/2096644622332383734
- Theo reports that Fable 5.1 and GPT-6 Astra had a “profound impact” on how much they could ship; the post provides no benchmark, task breakdown, or replicable workflow, so this is a qualitative productivity signal rather than a practical technique.
- The thread points to an open-source GitHub repo and says the tracker was turned into a Lakebed app: https://t3code-velocity.lakebed.app/.
- Kent C. Dodds reports a firsthand delegation loop: over two months, he delegated tasks he had previously handled himself to Grok’s bot and shifted his time toward higher-leverage activities. He also says he is looking forward to Grok 4.7.
- His recommended pattern is to “hire” the coding agent to take over your current work, use the freed capacity for higher-leverage work, and repeat the cycle.
- Fable quota management (Theo, firsthand): Theo reports that an unused account used about 22% of its 5-hour allowance while consuming about 9% of the Fable 5 weekly quota, implying that one 5-hour window can consume roughly 40% of the weekly allowance. He adds that starting a long prompt with one hour left in the 5-hour window can consume about 60% of the weekly quota in a single prompt.
- Model-capability take: Theo characterizes his workload as exceeding what Sonnet can handle: “Not all of us are building shit that Sonnet is capable of.”
- Firsthand Treg workflow: Shaolong2026 is building a content engine that collects competitor Meta, Google, and TikTok ads; creator videos and breakdowns; and Semrush, keyword, and landing-page insights. It produces static ads with Astra, with ads and organic videos via Seedance planned next.
- Ecosystem signal: Jason Zhou highlighted that more GTM practitioners are building on Treg and linked to this project.
Adam Holtererer says Astra cloned Dead Center Arcade in two prompts, linking both the result and the original post.
- Kent C. Dodds announced that Kody would launch that week and said it addresses problems people have been posting about.
- The linked @larsencc discussion identifies a concrete agent-orchestration problem: sharing memory across all agents, potentially through a global memory layer.
- Riley Brown proposes an agent-native game-hosting platform rather than an agent that builds games: a user would copy the platform link into Codex, Claude, or Grok and use the prompt, “Please make this game multiplayer so i can play it with my friends”; the agent would read the platform’s documentation and host/list the game.
- The proposed integration should minimize user friction and handle practical multiplayer infrastructure such as a real-time database and latency; Brown also suggests free access initially, with game discoverability and later in-game purchases as potential platform economics.
Kent C. Dodds recommends doing a workflow “the hard way” before building automation or agent systems around it, because firsthand experience helps avoid optimizing the wrong process. He also cautions against creating reusable agent skills after only one successful turn; validate the pattern before codifying it.
Geoffrey Huntley endorses Dominik Tornow’s thesis that recent models can generate code, while code verification—including testing—remains the unsolved bottleneck; the verification harness should be treated as the software factory. For coding-agent workflows, prioritize an executable verification and testing harness around generated changes rather than focusing only on code generation.
Astra warning from @mitsuhiko: when it is “one step removed” from normal code, it produces “weird Python slop,” and its generated unit tests are “absolutely horrific.” Treat Astra-generated Python and tests as requiring independent manual review rather than trusting the tests as an oracle.
Armin Ronacher had Astra implement Java-inspired virtual threads for Python with structured concurrency. He described the result as “total useless slop,” but said the exercise was useful for validating the idea. He then identified a concrete Python limitation: its lack of scoping means every async block must introduce an interpreter frame, making the approach frustrating and “super un-pythonic.”
Theo warns that giving enterprise developers unlimited AI tokens can accelerate shipping, but also expands the surface area for bugs, regressions, and jank. His practical recommendation is to have developers actively use and evaluate the product as AI-driven changes are introduced; otherwise increased development speed can make the product deteriorate faster.
-
DHH reports wiring
muse cliinto Omarchy for two agent-integration modes: making it the default agent action and supporting lazy-loading. The implementation is linked in Omarchy PR #9915.
- NeoHack: Tobi reports that GPT6 Astra created a headless version of the 42-year-old game Nethack, with the model’s game-playing capability exposed for reuse as a library, MCP, or JavaScript library; the project is available at neohack.dev.
- DHH describes the project as originating from a track-side conversation and a hunch that newer models could modernize an old game, illustrating a practical pattern of using an agent to wrap legacy software with modern programmatic interfaces.