Theo (t3.gg, creator/maintainer of T3 Code — his open-source alternative to the Codex app with ~120,000 users) recounts a firsthand debugging story: T3 Code's browser GPU process was eating 13–15% CPU at 720p and up to ~50% at full resolution on a 5K display, and it took him ~1.5 days plus two nights until 5am to fix Theo - t3․gg.

• Why the agents failed at first: Giving the Codex agent a vague problem description produced a plausible diagnosis and a 10,000+ line PR rewriting the network/React update layer — which changed nothing Theo - t3․gg. Codex, Sol, and Fable all fixated on wrong suspects (the "Ultrathink" composer gradient, a UI that only renders when Claude Code's ultrathink mode is active and wasn't even in use; a loading skeleton), and Chrome's AI-generated performance summary blamed the same unrelated features Theo - t3․gg.
• The workflow that worked (replicable): stop asking the agent to solve the problem; ask it to build a bisection harness instead. Theo had the agent create a window-bound function (_t3gpu) that injects custom CSS into the production page, letting him toggle suspicious features (animations, filters, shadows, composer blur, media layers, noise layer) live from the console Theo - t3․gg. Toggling everything off dropped the GPU process from 20%+ to ≤3%; resetting it spiked usage back Theo - t3․gg. A second agent then generated a script to enumerate and pause all animations and split transitions vs. animations to isolate the culprit Theo - t3․gg.
• Root cause: a pulsing terminal icon in the sidebar — an infinite opacity animation. Each infinite compositor animation promotes its element to its own GPU layer and keeps the compositor committing at the display refresh rate (120fps on his high-DPI display), so several small sidebar layers get recomposited forever even when nothing else changes Theo - t3․gg. Backdrop blur plus a very low-opacity noise layer over the page amplified the cost Theo - t3․gg. The shipped fix removed the noise layer, retuned gray colors, and made animations finite or static Theo - t3․gg.
• Measurement caveat: Chrome DevTools itself changes site performance characteristics (debug-mode overhead), so Theo trusted the browser Task Manager over profilers, which become near-useless once work is offloaded to the CSS/compositor layer Theo - t3․gg.
• Surprising datapoint: an empty, idle Claude AI tab used ~10% of his laptop's GPU per open tab — three open Claude tabs masked his fix — and Claude's suggestions for the animation fix were (in his words) bad enough that he rejected them all, including a proposal to remove pulsing entirely rather than make it finite Theo - t3․gg. He built T3 Code partly because the Codex desktop app repeatedly regressed performance across updates Theo - t3․gg.
• Multi-agent pattern: Theo ran Sol-based and Fable-based agents simultaneously on two separate machines over T3 Code, deliberately isolated so they wouldn't interfere or get confused by each other's in-progress solutions Theo - t3․gg.
• Timeless takeaway: the agents couldn't diagnose or fix this — the human still brought the real information — but they were genuinely valuable as fast codebase searchers and as builders of custom diagnostic tools for the human's theories; diagnosis by hand would have taken far longer Theo - t3․gg.
• Related product news: T3 Connect (connecting agents to T3 Code without needing Tailscale) is coming soon Theo - t3․gg.

Geoffrey Huntley, writing from experience at Canva, argues LLMs generate better code than most companies can hire at a price cheaper than a human — but outsourcing thinking is an "engineering crime" @GeoffreyHuntley. He frames LLMs as a "time compression device": deciding what to build, and delivery (working software and product experiences that create value, not generating code), remain the hard parts @GeoffreyHuntley.

At Canva, he observed that LLMs reward experience, yet experienced engineers "BFFs with IntelliJ and their favourite keyboard" were being left behind by "wild-brave-fresh-eyed juniors" — which he calls dangerous @GeoffreyHuntley. A chart on ghuntley.com/screwed/ (Feb 2025) makes the underlying point: the more experience and domain knowledge, the better you can drive LLMs @GeoffreyHuntley.

Resources linked in the thread: The Register's special feature on the "Ralph Wiggum loop" — prompting Claude to vibe-clone software — at https://www.theregister.com/special-features/2026/01/27/ralph-wiggum-loop-prompts-claude-to-vibe-clone-software/4211889, plus ghuntley.com/redlining @GeoffreyHuntley; and his take that software engineers are "clowns as a profession" versus engineering fields that require professional liability (ghuntley.com/squirrel-burgers/) @GeoffreyHuntley.

Simon Willison released LLM 0.32, calling it the most significant version since launch; it ships GPT-5.6 family support with GPT-5.6 Luna as the new default model, and he says the project is becoming "very agent-shaped" — powering Datasette Agent and llm-coding-agent. simonwillison

• Reasoning traces from reasoning models now go to stderr, keeping stdout clean for piping; use -R/--hide-reasoning to suppress. simonwillison
• Server-side tools: llm --tool CodeInterpreter 'Show current python and SQLite versions' uses OpenAI's code execution environment; WebSearch is also available. llm-anthropic 0.26 adds WebSearch, WebFetch, CodeExecution, and AnthropicMCP — e.g. llm -m claude-sonnet-5 -T 'AnthropicMCP("https://datasette.simonwillison.net/-/mcp")' 'how many rows in the blog_blogmark table?' runs MCP tools inside one request/response. simonwillison
• New llm openai endpoint runs one-off prompts against any OpenAI-compatible endpoint (not logged) — e.g. local LM Studio Gemma 4 12B with a QuickJS tool: uvx --with llm-tools-quickjs llm openai endpoint http://localhost:1234/v1 -m google/gemma-4-12b -T QuickJS 'Use QuickJS to multiply 3434 * 2434' --td, no LLM install needed. simonwillison
• Python API: model.prompt(messages=[system(...), user(...), assistant(...)]) sends full history in one call, and stream_events() yields typed events (reasoning/text/other) for mixed reasoning+tool+image outputs. simonwillison
• New llm-chat-completions-server plugin exposes an OpenAI-compatible v1 endpoint (llm install llm-chat-completions-server && llm chat-completions-server --port 9000), consumable via llm openai endpoint. Logging got a Git-like content-addressable message store to avoid duplicating history JSON; llm logs/llm logs --json still work. simonwillison
• Agent-loop primitives: tool chains can pause for human approval and resume from stored history — added for Datasette Agent; Willison now defines an agent as "runs tools in a loop to achieve a goal". Existing model plugins must be upgraded to 0.32 for the new streaming events. simonwillison

An X post by @reach_vb says most of OpenAI's Developer Experience team is meeting this week to plan, build, and think about what to do better for developers, inviting feedback on what to build and what's missing @reach_vb. Simon Willison replied with a concrete ask: "Ship OAuth so I can build LLM features for my web apps that get billed to my user's existing OpenAI accounts" @simonw — a request for user-owned-account billing that would let developers ship LLM features without fronting API costs.

@SocketSecurity reports an active npm worm still spreading: 2,234 affected package artifacts across 444 unique packages, with average detection time of 5 min and 18 seconds after publication; their campaign page lists affected packages/versions @SocketSecurity. @bentossell amplified the update with "phew (i hope)" @bentossell.

Luna cheap after 80% cost cut, used as always-on auxiliary model in T3 Code — @theo says Luna is "basically free" after an 80% cost reduction and can handle "real data processing type work"; he's overhauling T3 Code's title generation to use it and wants to spin it up on every prompt for descriptions, feedback, and statuses @theo. Practical pattern: when a model becomes near-free, attach it to every prompt for cheap auxiliary outputs.

Tool-call visibility debate — In the thread, @maria_rcks wanted Luna specifically for tool-call summaries @maria_rcks; @theo argued people don't need to actually read tool calls anymore @theo; @swyx countered that tool calls should still be shown as audit functionality and exported, linking a session portability post (https://earendil.com/posts/session-portability/) @swyx. Timeless pattern: keep agent tool calls as an auditable, exportable log even if the UI de-emphasizes them.

Kent C. Dodds (@kentcdodds), developer and educator, takes a contrarian stance on agent-generated tests: "Your agent writes bad tests and you yell at it. My agent writes bad tests and I let it do it anyway. We are not the same" — he accepts imperfect test output from his coding agent rather than pushing back on it @kentcdodds. A reply from him links a YouTube video (https://youtube.com/watch?v=5C0jTimK8V0&list=PLV5CVI1eNcJhP4nrJt85L7PxHjebFpDfY) asking viewers to watch, comment, subscribe, and share @kentcdodds.

• @theo says Luna is "such an insane value" after an 80% cost reduction — "basically free" and capable of "a ton of real data processing type work." He's overhauling title generation in T3 Code to lean on it and wants to spin it up on every prompt to generate descriptions, feedback, and statuses @theo.
• @swyx observes that "good enough" intelligence is now "too cheap to meter," which is why ontologies and graph knowledge are finally trending; the hardest part of knowledge graphs has become cheap, so complements are increasing in value. He links this to @theo's Luna post @swyx.

Guest author Shlok — known for teardowns of AI-lab memory systems — unpacks OpenAI's ChatGPT Work (launched July 9, 2026) from hands-on probing with Codex, with linked conversation logs throughout Latent.Space.

• What Work is: an agent for knowledge work that runs on the Codex harness and lives in a persistent cloud microVM — Pro gets 8 CPUs/20GB RAM/64GB disk, Plus 14GB RAM — plus a managed Chrome service; it outputs Sheets/Docs/Slides and hosted Sites Latent.Space. Desktop Work has cloud and local modes; local mode is "essentially Codex, minus the code-related UI traces", and local tasks don't sync to web/mobile with no migration path yet Latent.Space.

• Persistence architecture: the workspace syncs to persistent storage and is restored onto isolated microVMs; each thread gets a /workspace/scratch directory with full OS freedom (folders, dependencies, scripts, databases). Cross-thread continuity runs through the ChatGPT product layer: compressed summaries of recent tasks/files, a Personal Context tool that queries Chat and Work history, and a Library for files that lives off the computer and does not sync with thread-local copies. An agent can browse other tasks' scratch dirs only when explicitly instructed, and won't do it on its own Latent.Space. There is no meta-layer agent coordinating between tasks yet — some users already run Codex that way Latent.Space.

• Proactivity & scheduling: new conversations surface personalized suggested tasks generated asynchronously from calendar/Gmail/memory, injecting a pre-authored prompt; nothing runs until the user executes Latent.Space. Scheduled tasks come in two forms: standalone (saved prompt, fresh task per run) and heartbeat tasks inside an existing conversation that reawaken it with context intact — heartbeats are desktop-only for now; triggers can be exact time, a loose window like "in the morning", or a monitored condition Latent.Space.

• Browser use: Work drives a separately hosted Chrome via tool calls, with a persistent profile (logins/preferences carry across tasks) and a synced permission ledger; users can take over the live browser on web/desktop, not mobile. Datacenter-browser constraints: Amazon US rejected it as an unsupported session, Google Photos timed out, and CAPTCHAs require explicit permission — no fingerprint rotation or evasion; the same tasks worked in local mode Latent.Space.

• Plugins/skills/tools: a plugin bundles apps (mostly MCP-server tools), skills (instructions + references/templates/scripts), and app templates; three types: operational (Computer Use, Sites, Documents), role-specific (e.g., Sales plugin teaches 20 skills across 29 apps), and service (Gmail, Slack, Notion, Figma, Salesforce, PitchBook). The Plugin Directory holds 1,000+ plugins but discovery is weak — Work ignored available travel plugins for flights/hotels in favor of web search, even when Expedia was named Latent.Space.

• Scale/trajectory: Work + Codex reportedly crossed 10M users three weeks in; Greg Brockman confirmed Chat and Work will merge by end of 2026 Latent.Space.

Simon Willison (@simonw) announced a major new release of LLM, his CLI tool and Python library for talking to hundreds of different LLMs, adding reasoning traces, OpenAI Responses support, server-side tools, and smarter logging @simonw. Detailed write-up: https://simonwillison.net/2026/Aug/4/new-release-of-llm/@simonw

@kentcdodds built an automated Sentry-to-fix loop: a Sentry webhook sends errors to Kody Koala, which then kicks off a Cursor cloud agent to investigate and fix the error; if the fix is low risk, the agent merges, deploys, and verifies in production @kentcdodds. He called this 'loop engineering' @kentcdodds and later called it 'by far my favorite loop' @kentcdodds. The description is firsthand but high-level — no setup steps, prompts, or configuration details were shared.

Kent C. Dodds (@kentcdodds) accidentally started a Cursor cloud agent in the wrong repo; instead of giving up, the agent used Kody Koala (@kodykoala) to spin up a separate agent in the right repo and monitored its process for him. @kentcdodds

• @tomas_hk announced Not Diamond Code, an intelligent model router for long-horizon coding agents. It works with any gateway or harness, including Claude Code, selecting the best model and reasoning effort for each step, and claims to reduce costs by 20-65% without impacting quality @tomas_hk.
• Mckay Wrigley (@mckaywrigley) is "bullish" on routers: same performance at lower cost is "obvious," but the bigger opportunity is blending multiple "jagged" models into "smoother" intelligence — "the era of model melding begins" @mckaywrigley. He frames the evolving stack as "model engineering -> harness engineering -> router engineering," a third new layer for increasing intelligence, and predicts "surprisingly robust gains" here @mckaywrigley.
• Firsthand, Wrigley tested deepseek v4 flash last night — "basically free" — and found "a half dozen things" it handles well enough to offload from his "fable 5 workflow" @mckaywrigley.
• Link: https://x.com/tomas_hk/status/2084669945150062619@mckaywrigley

• Mario Zechner (@badlogicgames) observes that "everybody is building chatboxes with connectors now," linking to a Cursor AI post — a critical take that the industry is converging on the same chat+connector pattern for agents @badlogicgames.
• Riley Brown (@rileybrown) frames this evolution as "Agent Chat + Connections + Browser + Automations = Superapps," suggesting these components combine into superapp-like agent experiences @rileybrown.

Kent C. Dodds (@kentcdodds) describes a 'conductor' agentic orchestration system he built: one conductor agent spawns individual Cloud Agents (via the Cursor Cloud API), each with its own environment, and shepherds them to get changes into production; communication flows through the Kody Koala MCP @kentcdodds. The conductor replaces him in babysitting the other agents; each agent can itself orchestrate sub-agents @kentcdodds. Worked example: when an agent struggled to open a PR, the conductor used Kody to create the PR and messaged the agent that its PR was ready for review @kentcdodds. Sub-agents report completion back to the conductor via Kody @kentcdodds. When the run finishes, the conductor sends him a Discord summary of everything that happened @kentcdodds.

Geoff Huntley (@GeoffreyHuntley) reports being on day 2 of using ssh_exe_dev (by @davidcrawshaw) as his full-time, day-to-day “ephemeral experiment driver,” and credits Crawshaw's product execution and taste @GeoffreyHuntley.

Firsthand complaint: @kimmonismus is canceling Claude, citing a recurring failure in his email agent workflow (Claude checks inbox for important emails, summarizes, works with them, and sends replies when necessary): Claude repeatedly doesn't read the email thread to the end and ignores the latest emails; when challenged, Opus 5 admitted, "Valid point. I didn't read it." @kimmonismus @theo replied with partial agreement ("Yes but also…") and praise for Fable: "fable is so good." @theo

OpenWiki v0.3 (npm install -g openwiki@0.3.0) is out with a full prompt rewrite aimed at generating more detailed and accurate wikis @BraceSproul. In a firsthand update, @BraceSproul reports eval results at n=2: 28.57% success increase (35% → 45%), 14% fewer tokens, and 26% fewer tool calls per successful task, with wikis containing much more data @BraceSproul. LangChain amplified the release, calling the upgraded init prompt higher-quality and more codebase coverage @LangChain. Repo: https://github.com/langchain-ai/openwiki@BraceSproul.

Firsthand (Theo/t3.gg): Luna is "insane value" after an 80% cost reduction — "basically free" and useful for "a ton of real data processing type work" @theo. He is overhauling title generation in T3 Code to take more advantage of it, and wants to run it on every prompt to generate descriptions, feedback, and statuses since it's basically free @theo. In reply context, @maria_rcks wanted to use Luna for tool-call summaries @maria_rcks; Theo's take: people don't need to actually read the tool calls anymore @theo — suggesting cheap generated summaries/statuses can replace manually reading raw agent tool traces.

LangChain announced model fallbacks in LangSmith LLM Gateway: define fallback rules across models and hosts, used across every agent; when a provider goes down or rate-limits, calls route to another model, so outages don't take agents down @LangChain. Details at https://www.langchain.com/blog/langsmith-llm-gateway-runtime-controls-for-production-agents@LangChain.