Direct answer: use the five line-addressable candidates below. The supplied transcripts contain no clock timecodes, so reliable approximate timestamps cannot be recovered; use the cited line ranges as edit boundaries and verify the final 2–5 minute duration in the video.

1. AMP — phased deployment, rollback, and least-privilege production access

Priority: highest AMP cut. Target: 3–5 minutes. Transcript block: L55–L60. AMP describes a migration from one workspace to multiple that requires backwards-compatible phases; after each deployment, the agent monitors logs, the database, and invariants, advances when healthy, and rolls back when not. Latent Space The proposed access model is an orb agent receiving an OIDC token for 30 minutes of read-only access limited to G-Cloud logs or the production database. Latent Space

2. Riley Brown — PDF → Blender → playable game map

Priority: highest Riley demo cut. Target: 3–5 minutes. Transcript block: L4–L10. Riley starts with a PDF containing an estate, house, and floor plan, passes it to Codex/GPT-6 Astra to control Blender, gets a house generated in about 20 minutes, then asks the agent to turn it into a new playable “Estate” map in an existing Call of Duty-style game; after about an hour, it returns both the Blender scene and playable map. Riley Brown The demo then shows the generated house in-game, including a helicopter that can be flown and used in combat. Riley Brown

3. Riley Brown — concrete self-testing loop

Priority: highest practitioner-workflow cut. Target: 4–5 minutes. Transcript block: L42–L49. Riley explains the loop as: perform the task, evaluate the result, make changes, and re-evaluate repeatedly. Riley Brown For the estate project, the agent screenshots and evaluates Blender, checks that the game builds, starts a match, moves around the map, boards and flies the helicopter, and checks the house; after noticing an incorrect white texture, it reprompts itself and iterates. Riley Brown Riley’s qualification is that a hard paywall can still stop the process; otherwise, he presents the agent as testing repeatedly until the requested end state is reached. Riley Brown

4. AMP — CI as a deterministic agent feedback loop

Priority: strong AMP workflow cut. Target: 2–3 minutes. Transcript block: L81–L84. AMP’s agent runs tests in a sandboxed, reproducible environment, but CI remains useful as a deterministic stage that runs the full test set, passes failures back to the agent, and lets the agent fix and retry. Latent Space For editorial balance, the surrounding discussion says part of the AMP team questions whether CI is still necessary, while retaining the value of a reproducible environment for running the project. Latent Space

5. AMP — remote orbs and parallel cloud development

Priority: useful context cut. Target: 3–5 minutes. Transcript block: L11–L20. AMP describes orbs as remote workspaces that let developers shut their laptops and run roughly 100 tasks in parallel, changing how the team and customers work. Latent Space The concrete workflow is an agent running in the cloud with a dev server exposed in a portal, desktop access, and parallel execution; the speaker says that once the cloud setup works, developers may stop using local development. Latent Space

• Expert-directed agent build (firsthand, Graham Dumpleton): Wrapture extends wrapt-style monkeypatching into testing and tracing, can override or observe arbitrary functions, supports OpenTelemetry, and offers configuration-only tracing. Simon Willison’s Newsletter Dumpleton says every line of code and documentation was written by an AI assistant under his direction, with the design supplied by his own domain expertise rather than a one-shot “vibe coding” prompt. Simon Willison’s Newsletter A reproducible tracing setup is:

  capture = "summary"
  
  [[observe]]
  target = "domain:Calculator"
  name = ["outer", "inner"]
  
  [[sink]]
  type = "jsonlines"
  path = "trace.jsonl"

  Simon Willison’s Newsletter Its test API supports both stubbing Gateway.charge() and transforming the original method’s return value while still executing it. Simon Willison’s Newsletter

• Separate builder and reviewer models: Simon Willison’s claude-system-prompts repository stores model-family prompts with synthesized, date-aligned Git histories so changes can be diffed directly. Simon Willison’s Newsletter He had Claude Fable 5.1 build the system and automation, but routed prompt-diff summaries to GPT-5.6 Luna because he did not trust Claude to summarize its own system prompt; a GitHub Actions workflow runs daily or manually. Simon Willison’s Newsletter

• Iterative local artifact workflow: In ChatGPT Codex on macOS, Willison installed the full Blender application and started with Use the already install /Applications/Blender to render a scene of a pelican riding a bicycle, then iterated with OK add a background and a lot of flair and OK make it a whole lot better. Simon Willison’s Newsletter Codex generated the scene through Blender’s Python API, with the resulting script published in the gpt-6-astra-blender-pelican-bicycle repository; the subscription covered the run, while AgentsView estimated an API-equivalent cost of $4.24. Simon Willison’s Newsletter

• Model/context evaluation signal, with a major harness caveat (secondhand): Willison had not yet tried GPT-6 Astra himself; OpenAI priced it at $10/million input and $50/million output and reported a 99.9% ARC-AGI 3 score. Simon Willison’s Newsletter That 99.9% result required OpenAI’s custom Provider Adapter harness and $19,000, while the default harness scored 62.7% at $26,000; the adapter preserves opaque reasoning state between requests and compacts long conversations. Simon Willison’s Newsletter OpenAI also reported 100% on its eight-needle benchmark at 256K–512K tokens and 96.3% at 512K–1M tokens. Simon Willison’s Newsletter Artificial Analysis found Claude Fable 5.1 ahead on its overall Intelligence Index, but Astra ahead on the Coding Agent Index cost-efficiency frontier and less than half the per-task cost of Fable 5 at the same score. Simon Willison’s Newsletter

• Agent-facing tool updates:datasette-mcp 0.2 changed execute_sql results from arrays of arrays to arrays of objects so weaker models do not have to track positional column mappings; it is the project’s first non-alpha release and now depends on mcp>=2.1.1. Simon Willison’s Newsletterllm-gemini 0.34 added Gemini 3.8 Flash with low, medium, and high thinking levels. Simon Willison’s Newsletter Willison used it with his basic llm-coding-agent plugin to add sandboxed-iframe rendering for HTML blocks to his Markdown/SVG renderer; a separate “make me a cool thing in html” run took 13 seconds and cost 1.8 cents. Simon Willison’s Newsletter

• Review-risk counter-signal (firsthand Rick Brewster): The Paint.NET author reports that Claude produced a 180,000-line, clean-room Direct2D rewrite for WINE, but says most of it was not thoroughly reviewed; he had to supervise COM reference-counting fixes such as missing AddRef() calls and reject poor architecture decisions. Simon Willison’s Newsletter

• Effect v4 beta and setup: Effect v4 was presented as a beta release that consolidates previously separate packages into the core effect package and includes 17 unstable modules spanning HTTP, AI, schemas, RPC, CLI, workflows, and clustering. ThePrimeTime The walkthrough used TypeScript 7 with strict: true and installed effect@rc. ThePrimeTime
• Learn before delegating to an agent: The host recommends reading documentation to avoid missing small concepts, rejected starting from an AI-generated Effect setup he could not explain, and warned that visible progress without understanding is a “false illusion of progress.” ThePrimeTime TJ’s suggested learning progression was to have an agent build a minimal Bun HTTP server with a health endpoint, then extend it into a CLI-backed to-do app using local SQLite/Drizzle, and only afterward add a frontend. ThePrimeTime
• Constrain agent-written TypeScript with typed boundaries: Guest TJ’s Effect pattern is to encode specific error types and service requirements in the program type, provide required services or composed layers at the boundary, and let missing requirements fail type-checking instead of relying on a global dependency grab bag. ThePrimeTime This also supports testing: a production user service can depend on Postgres while a test implementation simply returns fixtures or a not-found error; TJ says inspecting the type lets him verify that an AI-generated block cannot open a Postgres connection where it has not been granted one. ThePrimeTime
• Validate data and external calls: TJ’s codebase rule is that agents must define schemas rather than interfaces and parse data instead of trusting TypeScript assertions; for an unknown HTTP endpoint, an API specification can generate a fetch client that serializes and deserializes through those schemas. ThePrimeTime
• Use structured concurrency for parallel LLM work: The Effect example migrates ask to Effect’s AI language model generate text API and runs text-generation requests in parallel; if one fails, structured concurrency immediately interrupts the others, avoiding the manual AbortController cancellation wiring required by promise-based code. ThePrimeTime
• Anecdotal model signal: In a firsthand desktop-operation test, the host reported that “GPT56 Luna none fast” was over 50% successful at signing into a computer, reaching the lock-screen flow, and signing back out; the transcript gives no broader benchmark context. ThePrimeTime

• GPT-6 Astra + Codex (firsthand): Riley Brown reports roughly one week of access to OpenAI’s newly released GPT-6 Astra and about $1,500 in usage; he says he built a Call of Duty-style game in four prompts and added multiplayer in the fifth. Riley Brown
• Replicable multimodal agent loop: Feed Codex a PDF containing an estate’s photos and floor plan, ask GPT-6 Astra to drive Blender to build the 3D scene, then instruct it to turn the result into a playable game map; Brown reports roughly 20 minutes for the Blender scene and about an hour for the scene-plus-map workflow. Riley Brown The reusable pattern is to specify the end state and let the agent inspect, test, and reprompt itself: it took screenshots, evaluated the Blender output, launched and played the game, tested the helicopter and map, noticed an incorrect texture, and iterated. Riley Brown
• Prompt-to-utility workflow: Brown asked Codex for a shortcut-opened, Raycast-style desktop app that searches Google Images, removes backgrounds, and saves copied assets; he reports a working app in 16 minutes. Riley Brown Semicolon-separated terms trigger multiple searches, Command-Enter uses AI to generate searches from a list of entities, and copied assets remain available for reuse. Riley Brown
• Harness comparison and access model: Although Brown says GPT-6 Astra can also run in Cursor, he found it substantially more capable in Codex, attributing the difference to integrated computer/browser use, local app control, file editing, and website testing; he also describes controlling the desktop remotely from a phone. Riley Brown The workflow depends on full access to the host computer, including signed-in browser sessions, GitHub/deployment accounts, and API keys, making permissions and security a core constraint when reproducing it. Riley Brown
• Prototype deployment and always-on orchestration: For a game lead magnet, Brown used the hosted Sites workflow to create a signup page, collect contact information, and add an admin dashboard restricted to his email. Riley Brown He plans to run Codex and other agents continuously on Mac Minis/Linux and control them remotely from a phone or iPad; this is a proposed setup rather than a completed result. Riley Brown

• Firsthand model/tool report — GPT6 Astra in Codex. Riley Brown says he had access for about a week before release and spent roughly $1,500 in credits; he reports building a Call of Duty game in four prompts, adding multiplayer in prompt five, and streaming it with 20 people. Riley Brown
• PDF → 3D asset → playable map. Feed an estate PDF to GPT6 Astra inside Codex, ask it to control Blender and recreate the property, then have it verify the scene and build a new map in the existing game’s format; Riley says the Blender output took about 20 minutes and the playable map arrived after about an hour. Riley Brown The demonstrated reusable loop is: inspect screenshots/renders, build and launch the artifact, interact with it, evaluate the result, reprompt, and retest; the agent reportedly noticed an incorrect house appearance and iterated on it. Riley Brown
• One-prompt local utility pattern. Riley asked Codex for a Raycast-style desktop app launched by shortcut that searches Google Images, removes backgrounds, and saves copied assets; he says it produced the app in 16 minutes. Riley Brown The interaction design uses Command-Shift-Space to open it, semicolon-separated terms for multiple searches, and Command-Enter to have AI turn a multi-person input into separate searches; copied or saved results remain searchable later. Riley Brown
• Harness advantage and access caveat. Riley reports that GPT6 Astra feels more capable inside Codex than in Cursor because the Codex harness provides computer and browser use, screenshots, Blender access, website testing, and file editing/deletion. Riley Brown This setup depends on full computer access and logged-in applications: he says the agent can use his browser sessions, GitHub/Vercel, and system API keys. Riley Brown
• Hosted app/lead-magnet workflow. Riley reports a sites capability with hosting, database storage, and authentication; his example asks for a site styled after his game, collects visitor information, and exposes an admin dashboard only to his email before sharing the site for feedback. Riley Brown
• Remote-agent architecture (planned). Riley says he bought two Mac Minis and intends to keep Codex and other agents running 24/7 on a Mac Mini/Linux setup, controlling them from a phone, iPad, or MacBook; he presents this as a setup he planned to implement that week rather than a completed workflow. Riley Brown
• Secondhand model comparison. Riley cites another person’s Microsoft Paint test comparing GPT6 Astra with Fable 5.1 and interprets the visual result as substantially favoring Astra for computer use; he also says OpenAI appears to be pulling ahead of Anthropic on that dimension. Riley Brown

• Firsthand context: Quinn describes AMP’s 20-person distributed team as an early, serious user of its own coding-agent workflow. Latent Space
• Remote parallel-agent workflow: AMP’s “orbs” run the agent remotely, letting developers close their laptops and run roughly 100 tasks in parallel; Quinn says this changed how the team works. Latent Space An orb starts a sandbox and exposes the dev server through a portal, with parallel jobs designed not to conflict and to receive the required access automatically. Latent Space
• Deployments as an agentic control loop: For a risky multi-workspace data-model migration, AMP broke the rollout into phases. After each phase, the agent monitored logs and database invariants, proceeded only when results were clean, and rolled back when they were not; Quinn used this process during a 12-hour flight. Latent Space
• Least-privilege production access: Quinn’s proposed security pattern is to give a cloud-running agent intentionally limited access, obtaining an OIDC token valid for 30 minutes with read-only permissions scoped to selected cloud logs or the production database. He argues this can be safer than a local agent inheriting broad credentials from a developer’s laptop. Latent Space
• Testing and CI loop: AMP runs the agent’s tests in a reproducible sandbox environment shared by the team. Quinn still sees value in a deterministic CI stage that runs the full relevant test set, passes failures back to the agent, and lets it fix and rerun them because an agent may not realize which tests a large change affects. Latent Space His contrarian view is that traditional CI may eventually shrink or disappear if agents can reliably run everything and automatically eliminate flaky tests, while reproducible execution environments remain essential. Latent Space
• Sandbox choice: AMP currently uses E2B. Quinn praises its sandbox primitives and contrasts it with alternatives that lack capabilities such as resuming environments or network access. Latent Space
• High-trust shipping model: AMP has eliminated mandatory code review before merging. Quinn attributes that to a small team with high ownership and accountability, and favors shipping a fix within about 15 minutes of receiving logs or customer feedback; he explicitly limits this approach to fast-moving end-user software rather than all software. Latent Space
• Emerging “mini-app” pattern: AMP runs ad hoc internal applications in orbs and lets an agent modify them immediately; Quinn argues that direct agent customization can replace much of the settings-screen and integration overhead of conventional software. He suggests making these apps forkable while keeping front-end/back-end contracts, security, and privacy constraints stable. Latent Space

• Latent Space Frontier AEO tracker: Latent Space built the Frontier AEO tracker after a few billion tokens of prototyping, alignment, and scaling; its methodology runs six prompt variations over seven models with search enabled across 161 categories, including coding agents. Latent.Space Astra performs answer extraction using a score that weights first choices, alternatives, mentions, and negative anti-recommendations; the project also exposes prompt/answer pairs, cited sources, and failure analysis. Latent.Space

• Model-conditioned tool-selection bias: When asked for coding-agent recommendations, Fable/Opus favored Claude Code, Sol/Astra favored Codex, Grok favored Cursor, Muse favored Muse Code, and SWE-1.7 favored Devin. Latent.Space GPT models also produced notable recommendations for Claude, so the bias is not universal. Latent.Space The authors report consequential recommendation flips between model generations from the same lab and provide Opus→Fable and Sol→Astra comparison pages. Latent.Space

• Stability differs by model: In the Sol→Astra and Opus→Fable comparisons, the median number of sources was 9 for Sol, 5 for Astra, 11 for Opus, and 15 for Fable; the authors describe Astra as more “confident” or “efficient” and less likely to change its answer after a light paraphrase. Latent.Space A practical evaluation pattern is therefore to compare coding-agent recommendations across model families, current model generations, and lightly paraphrased prompts rather than trusting a single model’s recommendation. Latent.Space The study cautions that its sample is small and reflects scraped attempted tool calls rather than pretraining data; Gemini/Antigravity, GLM/Zcode, and DeepSeek/DeepCode were excluded because of errors and rate limits. Latent.Space

• Salvatore Sanfilippo’s contrarian model-level view is to separate the AGI label from practical coding capability: he says current AI still lacks complete overlap with human abilities and genuinely novel breakthrough invention, but may mark the beginning of AI overlapping with complex skills such as programming and already performing some economically important tasks very well. For coding-agent evaluation, the practical implication is to measure concrete programming performance and task value rather than wait for an AGI threshold. Salvatore Sanfilippo
• Sanfilippo speculates that overcoming context-window limits may require fundamentally different Transformer context management, such as combining a rich embedding/residual-stream representation with another stream capturing the model’s overall state and details. He explicitly presents this as possibly necessary—or possibly unnecessary—and offers no implementation or benchmark, so this is an architectural hypothesis rather than a replicable agent workflow. Salvatore Sanfilippo

• Firsthand workflow — Simon Willison: For a phone-recorded demo video he wanted to publish on his blog, Willison asked Claude Fable 5.1 in Claude Code for web to “build me this tool,” using a WebAssembly build of FFmpeg; the linked Claude session is available for reference. Simon Willison's Weblog
• The generated browser compressor supports five size/quality presets, configurable output dimensions, CRF, audio bitrate, encoder speed, H.264 profile, a 30-fps cap, metadata stripping, audio removal, and first-10-seconds-only encoding. Its reported run generated five versions in 11.8 seconds; the smallest was 145 KB, or 48% of the original. Simon Willison's Weblog

ThePrimeagen is experimenting with models that use an application through desktop interaction and predicts that, by 2027, this approach could replace many Playwright tests by crawling and operating the app directly. He says his current Omarchy experiment shows the approach is “shockingly powerful” and harder to reproduce with scripts, making model-driven desktop testing an emerging alternative to scripted end-to-end tests. @ThePrimeagen +1

• Local model layer: Fireship recommends Ollama for downloading and running open-weight models through a local CLI/API, keeping prompts private and eliminating per-inference cost; the trade-off is that frontier-scale models may require data-center-class hardware. Fireship
• Routing and cost control: The video’s “Nouter” router exposes one local OpenAI-compatible endpoint and supports fallback tiers: an existing subscription first, a cheaper paid model second, and free providers third. It also tracks usage and compresses tool output. Fireship
• Context management: Headroom sits between the agent and model provider, compressing tool outputs, logs, and other low-value context before it becomes billable input; the compressed material is cached locally and can be retrieved if needed, making the compression reversible. Fireship
• Coding-agent orchestration: Fireship presents OpenHands as an open-source autonomous coding agent that can work through GitHub issues, run continuously as a self-hosted “army” of agents, and use OpenAI, Anthropic, or locally hosted Ollama models. It is described as a top performer on SWE-bench Verified, but no score or reproduction details are provided. Fireship

Simon Willison used GPT-6 Astra (medium) in ChatGPT Work to build an animated D3 visualization that morphs between Mercator and Equal Earth; the resulting tool supports a slider and play button for exploring the transition. Simon Willison's Weblog This illustrates a practical rapid-prototyping pattern: give a coding agent a narrowly defined visualization request, specify the implementation library (D3), and have it produce an interactive artifact. Simon Willison's Weblog

• In a firsthand build, ThePrimeTime creator assembled the Omachi automation as a client-server system: cloud agents run through Cursor, Linear tickets track work and trigger actions, PlanetScale stores logs and actions, and Sentry measures session details to diagnose slow model behavior. ThePrimeTime
• The workflow reduced an effort that would have taken “a couple weeks” of manual tuning and testing to approximately two days with agent-assisted development. ThePrimeTime
• The practical takeaway is to optimize agents for real product outcomes—smooth, repeatable user experiences and security improvements—rather than treating generated demos or new model releases as the primary goal. ThePrimeTime

Addy Osmani describes a selective, risk-based code-review workflow:

• Run a multi-agent first pass on every PR to find bugs, verify findings, rank severity, and suggest fixes; keep final approval human for consequential changes. @addyosmani
• When a change has low blast radius and touches less-sensitive code, skip deep human review after the agent review is clean. @addyosmani
• Require an owner and human sign-off for core or sensitive paths, concentrating human effort on verification, constraints, trust, and recoverability—agents handle the first pass while humans cover blast radius. @addyosmani

Launch-day stability pattern (firsthand): Ahead of Kody’s launch, Kent C. Dodds asked Cloudflare and “Cursor/Grok/bot” to keep things running smoothly so he could make necessary adjustments and handle support, while separately requesting no major code changes for a while. @kentcdodds +2

• AI game-building loop (Riley Brown): Build a game with an AI agent, ask it to add multiplayer, then share a link with friends for immediate playtesting. @rileybrown
• Secondhand multimodal demo: A quoted post claims GPT-6 Astra recreated a 10-acre estate from a PDF in Blender, added it as a playable map to a Call of Duty-style game built the previous day, and added a flyable, shootable helicopter from one prompt. @agentnative_

Model behavior comparison — Theo: GPT-6 Astra has produced both “incredible things” and some of the “stupidest things” Theo has seen from a model, while Fable 5.1 generally “just does what I ask.” This is a qualitative signal of high capability but inconsistent behavior from Astra versus more predictable instruction-following from Fable 5.1. @theo

• Always-on local-agent pattern: Riley Brown says he is getting a Mac mini to run Codex 24/7 and wants one computer signed into everything he uses. @rileybrown He wants Codex running on his personal Mac with access to his browser, iMessage, files, and desktop apps; he says this has “closed the loop” on many daily activities and is making him consider running Astra profitably 24/7. @rileybrown This is a firsthand plan and observation, not a measured productivity result or confirmed completed deployment.

Kent C. Dodds offers a contrarian mindset for AI-assisted development: when developers feel that hand-writing code is being taken away, they should try to fall in love with solving problems rather than with manual code production. @kentcdodds

Geoffrey Huntley reports a concrete agent-assisted 3D workflow: seven hours into attempting a 1:1 rebuild of Australia in Unreal Engine from ArcGIS data, Astra found Blender already installed and used it to “vibe code” the protagonists. @GeoffreyHuntley +1 The practical pattern is to let an agent inspect the local environment and reuse available creative tools for asset generation before adding installation or setup work. @GeoffreyHuntley