We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
Muse Wonder: use the Full version, and expect mixed results
Meta launched two models. Muse Wonder is available on Meta's API and in Muse Code. Muse Wonder Full is only available to Muse Code users. Both have 1M-token context, and Wonder costs $4 input / $0.20 cached / $20 output per 1M tokens. Full has no per-token price yet . On Artificial Analysis's Coding Agents Index, Wonder Full scores 68 at max effort in Muse Code. That ties Claude Code with Sonnet 5.5 (68) and is just ahead of Opus 5.5 (66). Standard Wonder scores 63 .
The two versions are not interchangeable. Theo says standard Wonder over the API is "significantly worse" than Full . He notes they use nearly the same number of tokens, but Full matches Opus xhigh on AA while non-Full scores below GPT-6.1 Sol . His working setup pairs the models. He added Muse support to T3 Code, and in Orchestrator V2 he "often [has] Opus ask Wonder for code review, copy work, and architecture review" . In a three-way bug-fix test:
- Opus found the root cause and filed a PR.
- GPT-6.1 Sol wrote 300 lines of tests , but its fix would not have worked .
- Wonder Full pointed to an existing community PR and suggested merging that instead.
DHH says he has already shipped two Omarchy PRs built with Wonder. He wants faster max reasoning and a proper agent overview in the default harness .
Not everyone agrees. Riley Brown used it for five hours and went "back to codex and claude code" . Matthew Berman found the $15 plan doesn't include Full. He then ran out of a $50 plan in three minutes, with 429 errors . Alexandr Wang later said the cause of the fast quota burn was fixed and reset Muse Code quotas . On cost per task, AA puts Wonder (max) at $4.52, below Opus 5.5 ($5.98) but well above GPT-6.1 Sol ($0.72) .
Slop is an engineering problem, so fix it in the repo
Several practitioners made the same argument from different angles: bad agent output is something you engineer away.
- Make the codebase the memory (poteto). Give the agent a way to verify its own work. Then turn every nit, mistake and bad pattern you see into a constraint, using lint rules, compiler diagnostics, types and LSPs. "Forget rules and skills. you can add those later." Better still, refactor so agent anti-patterns become impossible, and pick frameworks that shrink the architectural search space .
- Build a PR pipeline with a safety net (Kent C. Dodds). Have agents produce high-quality PRs, use agent PR reviewers, and add feature flags plus a regularly tested disaster-recovery process . Only then connect input pipes so agent work starts without you. He says he has averaged 77 merged PRs a day over five days .
-
Enforce rules with hooks, not prompts (Geoffrey Huntley). Updating
AGENTS.mdstill leaves drift. His fix is a pre-commit hook that scans the diff for direct observability calls that skip his diagnostics module, fails the commit, and tells the agent to use the approved path . He also says to test skill packs against a no-skills baseline, to delete skills andAGENTS.mdevery couple of months as models improve , and to read each lab's model card for prompting guidance . - Ask for a simplification pass (Salvatore Sanfilippo, in Italian). Left alone, AI produces solutions much bigger than the problem, and that complexity makes later AI edits harder too. Once the code works, ask it to cut useless layers and over-generalized functions one at a time .
- Prototype, then rebuild (ThePrimeagen). He uses AI to build a first version to explore the system's shape, then designs a deliberate V2. One project is going from about 100k lines to an expected 25–30k because the tests and structure were better thought out . He also warns that agents tend to pile up flaky end-to-end tests, so decide what actually needs testing . He keeps to one or two active dev tasks at a time .
Claude flows: what the workshop added
At AI Engineer NY, Anthropic presenters explained dynamic workflows. The lead agent plans, then writes an orchestration program that launches agents, collects results and manages information flow . You can still pass in pre-configured specialist subagents . Practical points from the Q&A:
- Defaults are low, so ambitious tasks need explicit encouragement to parallelize .
- The model doesn't know its budget while running, so set a session budget .
- Subagents share a filesystem but can't be told through the API to message each other .
- Claude Console lets you inspect the payload passed along every edge of the workflow graph .
- In a stock-scanner comparison, flows cost "much more" than a single agent but found more details .
Simon Willison builds a feature by voice
Willison used the Codex tab's voice mode in the ChatGPT desktop app with GPT-6 Astra High against his local Django blog. He started with Start dev server and open in browser so he could watch a live preview . In about half an hour of talking while cooking, the agent asked clarifying questions . It built a new model, four importers (including Substack's undocumented /api/v1/archive endpoint), archive pages and search integration . In PR review he replaced a Git-subprocess importer with an API call, by typing . His verdict: voice is great for multitasking, but typing still wins for details like pasting errors or pointing at specific code .
Tools and plans
- Cursor is now part of The X Subscription. Paid plans share one usage pool with Grok Build and give twice the coding usage on Grok models. On the new plans, third-party models in Cursor move to API pricing. Existing subscribers can keep their current plan .
- T3 Code nightly adds an "update everything" button. It updates the app, every environment, and providers like Claude Code and Codex, then resumes your threads . Theo says his Opus-built ts-rust port, now shipped in T3 Code, cut typechecking time by 3x .
- DHH says he usually prefers agent contributions to Omarchy because agents write more complete bug reports, and that PRs are "mostly just proofs of concept now" . The flip side is that the backlog is agent-managed, so not every item will be picked up .
- Huntley treats coding-agent harnesses as interchangeable and prioritizes cheap token access. He built Underclass, a proxy over OpenAI subscriptions that pools quota and handles exhaustion through resets/failover.
- He voice-dictates prompts and asks agents for status, deployment status, and session learnings; because models change frequently, he considers direct agent work sufficient and cautions against swarms moving faster than he can understand.
- For GitHub reviews, he sends PRs through an API into a Copilot-reviewer loop: agents address review comments, while technical decisions are escalated to another agent that reports its choices for his architectural review.
- He also describes a high-trust setup for greenfield and research work: agents get sudo access on a separate development machine he can rebuild in about 10 minutes, and integration tests prevent commits unless they pass. He favors getting a usable version quickly and validating it through use before investing in hardening; afterward he focuses on verification such as observability, boundaries, and prompts. He stresses that safeguards should reflect the domain’s risks and that verification is needed as backpressure.
- Huntley said he had rebuilt three former employers’ offerings in under 10 days and planned to release the work under MIT; the projects included an AI-first internal developer platform and a Gitpod-like service that starts a VS Code container from GitHub. These were described as planned releases, not as already shipped open source.
- To understand agent-written code, he uses an agent to summarize a codebase and produce system or state-machine diagrams, then reviews diffs and expects to be able to explain and whiteboard-defend the design; he says this is not a “complete yolo” approach.
- His verification approach puts the whole system, including the operating system and application, under test. He describes property-based checks such as ensuring a checkout charges a customer only once, and Antithesis’s deterministic container-based testing with clock and network fault injection and time rewind; he notes that property checks can also run locally and that an LLM judge cannot establish worst-case behavior.
- When generated code misses established patterns, he treats it as a workflow problem to investigate and fix; he uses pre-commit hooks and generated deterministic inspection scripts for checks such as architectural boundaries, while noting that durable best practices are still unsettled.
- After code generation, ask the AI for an “ablative” pass: remove unnecessary layers and functions, and trim overgeneralized solutions. Sanfilippo warns that AI tends to make solutions more complex than the problem requires, which can also make later changes harder.
- For open-source maintenance, he uses AI to rank and analyze issues and pull requests, then personally checks the top five for urgency and cherry-picks worthwhile work instead of trying to process the full queue. He says AI has also made branch merges easier and that fetch, rebase, and checks can be delegated to an agent. For contributions, he recommends forking and implementing the feature, then opening an issue with a few lines in your own words explaining the intent; if you use AI to draft the message, send the prompt instead.
- For his Dwarf Star local-inference project, Sanfilippo says he never opened a source file in its 135,000-line codebase: he steered the design and specified it in Markdown documents, retaining an abstract mental model of how it worked. He says the project was entirely AI-written and delivered better inference quality than other projects; he started it after seeing subtle inference-graph errors in existing engines and difficulty keeping quality up amid frequent model releases.
-
Simon Willison used Codex in the ChatGPT desktop app’s voice mode against his local Django blog checkout, first starting the dev server to inspect a live preview; he dictated requirements while cooking for about half an hour, and Codex asked clarifying questions as it modified the code. The session used GPT-6 Astra High and produced the newsletter model, imports, archive pages, and search integration; the agent also found Substack’s undocumented
/api/v1/archiveendpoint and worked out its pagination. - Voice plus a live preview worked well for multitasking and broad feedback, but Willison switched to typing for precise changes; PR review caught an import script using a Git subprocess where an API was preferable for accessing a private repository, and he asked Codex to replace it before merging.
-
A reusable integration pattern: have a coding agent read a new API’s documentation and adapt an existing plugin as a reference. Willison used GPT-6 Astra to build
llm-openai-decisionsfrom the OpenAI Decisions API docs, inspired byllm-typesafe; install it withllm install llm-openai-decisions.
- The video sketches a reverse-engineering-to-agent workflow, but does not show a finished reimplementation: use Reverse Engineer Anything with a read-only native-binary analysis integration to inspect one feature in a local Premiere installation, then give a coding agent the resulting pseudocode, assembly, strings, symbols, calls, and references to attempt a Rust implementation.
- In its Apify sponsor segment, the video presents Apify’s MCP server as a way to connect an agent to thousands of “actors”: make a one-line connection, describe a task in natural language, and have the agent choose a tool and return structured data. Examples include scraping YouTube data and monitoring Amazon prices; the video says exposing a small set of core tools and running the selected actor in the background helps limit token bloat.
- Huntley’s loop-engineering workflow began with Cursor and manually run loops; he identifies filesystem-as-state as one pattern for autonomous software building. His “Z80” approach is to clean-room an existing application into specifications, then rebuild from those specs, with legality varying by jurisdiction.
- Treat agent output as a draft: Huntley found earlier models left stubs and partial implementations, so he focused on supplying completeness reasoning and verification. He still distrusts the tools, though he says newer models need fewer prompts about missing work.
- Budget for inference and monitor unattended runs: the interview recounts Huntley leaving an agent running and topping a credits-burn leaderboard; he says he became known for triggering quotas and rate caps. He also warns that subsidized token pricing can obscure the cost of exploratory projects at real rates.
- Claude Managed Agents’ dynamic workflows entered public beta: a lead agent creates a plan that runs across multiple agents in phases, then combines their results; Anthropic describes it as designed for ambitious workloads.
- At AI Engineer NY, Anthropic’s @cjav_dev and Harrison Stall presented a full-length workshop on Claude flows. Its write-up says they drew on Unix/Linux lessons to explain how agents can tackle bigger projects without overwhelming developers.
Meta’s Muse Wonder is available via API, while Muse Wonderful is available only through a Muse Code subscription. In the host’s coding-model comparison, Muse Wonderful scored 79 and Muse Wonder 78.8 on Deep Suite, ahead of Fable 5.1 (67), GPT-6 Astra (71), and Opus 5.5 (74); the host considers this benchmark a useful reflection of developers’ coding impressions. Early access came with severe quota limitations: after the $15 plan lacked the full model, the host exhausted a $50 plan in three minutes with 429 errors, then ran out again shortly after upgrading to $200; Meta’s AI head said the issue was known and being fixed.
Sanfilippo outlines an LLM-assisted clean-room workflow: use an LLM to turn existing code into a specification, delete the initial instance’s logs, then have a separate LLM instance reimplement the software from that specification. He connects the approach to a clean-room experiment, including an earlier Spectrum emulator effort.
- Huntley uses a fleet of agents that coordinate in parallel through a shared blackboard, recording changes such as contract edits and refactors; a separate agent runs a retrospective. In an experimental code-smell detector, he normalized retrospective text with a Python NLP library before feeding it to a fruit-fly-inspired method, which could identify recurring smells and detect them in new codebases.
- Treat agent compliance as an engineering problem, not just a prompt-writing problem: for example, add a pre-commit hook that checks diffs for direct observability calls lacking the required diagnostics module, then fails the commit and prompts the agent to use the approved path.
- Test whether skills or agent instructions help against a no-skills baseline, and periodically reassess or remove them as models improve; read each model’s release/model card because prompting guidance can differ between models. Huntley also recommends sticking with a model that works to reduce the overhead of adapting to frequent changes, while reevaluating when needed.
- Prototype with an agent, then deliberately rebuild: Prime first uses an AI-assisted prototype to explore features and system shape, then designs a more thoughtful V2 using what he learned. In one project, he expected to go from about 100,000 lines to 25,000–30,000, crediting better tests and structure—not fewer lines as a goal in itself—and says the rebuild gave him a stronger sense of ownership.
- Choose tests instead of defaulting to end-to-end coverage: He warns that prompting agents for features can produce excessive end-to-end tests, which can accumulate into thousands and become slow or flaky; decide what actually needs testing and trim unnecessary coverage.
- Limit active coding tasks to match your context-switching capacity: Prime says he generally handles one task, at most one or two development tasks, and starts losing focus at three or four; he can run more concurrently when he is not actively working through code.
- Anthropic’s dynamic workflows (“flows”) grew out of Claude Code’s “harness for every task” concept and support work that runs longer than a single agent or fixed roster. Claude determines the agent topology: the lead plans the work and writes an orchestration program to launch agents, collect results, and manage information flow; developers can still add preconfigured specialists. Flows are available in Claude Console for API developers.
- A demonstrated pattern distributed individual stock tickers to agents with isolated contexts, then reviewed their findings before producing a report. For agent fan-out, Anthropic cited evals and low defaults; explicitly encourage more parallelization for ambitious tasks. Set a session budget, since the model does not know its budget while running. In the scanner comparison, flows cost much more than a single-agent approach but were reported to find more details.
- Developers can inspect the workflow graph in Claude Console, including what the lead passed to each subagent; agents share a filesystem, but cannot be instructed through the API to message one another directly. For repeated runs, “dreaming” is a research-preview feature that reorganizes memory using past session transcripts; it is not built-in flow self-improvement, though the presenters suggested combining dreaming with hill-climbing.
Python 3.15 adds explicit lazy imports, which defer importing a module until its symbols are used. This may reduce startup overhead in Simon Willison’s LLM CLI plugin ecosystem: installing plugins with heavy dependencies such as sentence_transformers had added multiple seconds to each command invocation, leading him to recommend manual lazy imports to plugin authors.
WordCraft is an AI-assisted Microsoft Office clone attempt written in Rust and still in alpha; its creator had previously started AI-driven Photoshop and other Adobe-project clones . ThePrimeagen called it “cloning office with tokens” and joked it could not be worse than its predecessor; the posts provide no reproducible coding-agent workflow or evidence of a finished product .
Peter Steinberger says “vibes coding” is a slur . The quoted post he shared calls AI coding “precision engineering” and argues that models can produce more coherent architecture and code than average software engineers, potentially even top engineers, because of their larger context windows .
- Kent Dodds recommends a three-part quality and safety process for agent-written code: ensure agents produce high-quality PRs, use agent PR reviewers, and protect production with feature flags plus a regularly tested disaster-recovery process; he says the same process applies to human developers. He adds that, once those pieces are in place, teams can connect input pipelines to launch agentic work unattended; he reports averaging 77 merged PRs per day over the previous five days.
- Treat the codebase as agent memory: let agents verify their work, turn recurring mistakes and annoyances into constraints, and strengthen existing diagnostics such as lint rules, compilers, type systems, and LSPs. Refactor or choose libraries and frameworks so agent anti-patterns become impossible and the architectural search space is smaller.
Steinberger favors “6.1 Sol ultrafast” over “6 Astra,” describing them as roughly similar in cost but a “whole different game” at 250 tpm; the post gives no task or benchmark context and does not explain “tpm.”
Kent C. Dodds says he moved from wanting a better way to organize a list of running agents to talking to @bot about everything and letting it handle them; he no longer tracks how many agents are running.
Kent C. Dodds recommends using cloud agents in response to a developer reporting that running 20–30 subagents made an M5 Pro MacBook with 48 GB of RAM generate substantial heat; this is a practical option to consider when local high-concurrency agent runs strain a machine.
ThePrimeagen reported that Opus 5.5 had become “really really annoying” over the weekend, a negative practitioner signal about the model; he gave no specific cause or workflow details.
