We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
Coverage is incomplete: some monitored sources or documents could not be processed. This brief covers the available verified material.
Coverage is incomplete: this brief reflects the available verified material.
🔥 TOP SIGNAL
Omarchy is treating agent autonomy as a triage-and-merge problem. DHH says the project is 2,200 PRs deep and receiving nearly 100 new submissions per day; agents will help, but humans are still needed. The proposed unit of work is a trusted cluster: triage consolidates duplicates and prepares finished submissions, while agents and people review batches before whole tranches are merged—and user-experience decisions remain human-owned.
The pattern to steal: make agents produce reviewable merge units, not an ever-growing pile of individually plausible diffs.
⚡ TRY THIS
Encode the bar instead of repeating it in chat (Addy Osmani). Start with the outcome, definition of “done,” non-touch constraints, and whether reuse or refactoring is simpler. Then give the agent the exact build, test, and lint commands; turn recurring review rejects into reusable checks such as
/verify,e2e, and schema checks; run them before opening the PR and use/code-review. When the agent misses, write the lesson intoCLAUDE.mdor a skill rather than quietly fixing it by hand.Batch PR triage, then merge tranches. For a noisy repository, have an agent consolidate duplicates and cluster related fixes. Require manual and agent review plus serious QA effort for each cluster; keep product and UX acceptance with a human. This is DHH’s response to Omarchy’s backlog, not a claim that agents can safely auto-merge it.
Provision the environment before multiplying agents. Armin Ronacher found a controlled machine reachable over SSH more useful for day-to-day engineering than cloud environments where PostgreSQL was absent and database tests were mocked. Seven parallel agents can mean seven databases, Kafka clusters, and other service instances; even cached environment bootstrap was estimated at roughly seven minutes. Start with one faithful environment, then fan out only when each worker has isolated dependencies.
Use a real artifact request as a capability probe. Simon Willison’s prompt was:
I live atGPT-6 Astra ran for 27 minutes and returned an embedded visualization plus GPX and GeoJSON files. Inspect the artifacts—not just the prose—and, if useful, check whether the generated map is reproducible: Willison traced his result to a. Figure out 5K and 10K running routes from me that loop from my house. Use OSM data. visualizeskill emitting D3-based HTML.
📡 WHAT SHIPPED
Astra’s reliability reset fully propagated across Codex and ChatGPT Work. The product-team update says the reset addressed skills that over-triggered or prevented self-checks, context management that caused early stops or stale replies, and misconfigured engines that degraded quality.
DwarfStar support for DeepSeek Flash v4.1 is becoming a reproducible local-agent path. In Salvatore Sanfilippo’s demo, a 2-bit quantized model ran 50/50 across two MacBook M5 Max machines with 128 GB each, reaching roughly 29–30 tokens/s decoding and 700–800 tokens/s prefill; he notes that the quantization had not yet been benchmarked. The more interesting control surface is a smooth 0–100 thinking-strength setting that can be raised for a hard step and lowered afterward, combined with image inspection: the model rendered a Mandelbrot program, converted output to PNG, checked colors and zoom levels, and iterated.
The strongest desktop-agent setup is still hardware- and context-dependent. Riley Brown says he is experimenting with GrokBot, GPT Work, Meta Muse, and Claude Cowork without committing to a cloud setup. His known-good pattern is a remotely controlled 48 GB Mac running Codex + Astra, with browser accounts already signed in, access to an external video drive, Notion, and Google Drive; he reports that it can control DaVinci Resolve and Premiere and is more predictable than OpenClaw, at the cost of heavy token use.
🎬 GO DEEPER
- Boris Cherny — practical agent workflow. Start with codebase Q&A—how code is used, Git history, and linked issues—before editing. For a large change, ask
Before you write code, make a plan, approve it, then give the agent a verifier such as unit tests, Puppeteer screenshots, or an iOS simulator so it can iterate. Cherny also recommends short shared project context, checked-in MCP configuration, and treating the SDK as a JSON-producing Unix utility for CI and incident-response pipelines. He reports that about 80% of Anthropic’s technical staff use the tool daily, including researchers editing and running notebooks.
- Armin Ronacher — Pi Agent dev workflow. The useful section is the case for a minimal, shell-first harness: Bash and
rgcan pipeline discovery and transformations without dragging every intermediate result into context. The same discussion is a reality check on cloud-agent enthusiasm: local machines win when stateful services and private data matter, while Ronacher says he sees much clearer gains in side projects than in enterprise rollouts and does not yet see strong outcome evidence behind higher commit volume. Resources: pi.dev and arendel.com.
- Salvatore Sanfilippo — DeepSeek Flash v4.1 + DwarfStar. Skip the model-size discussion and watch the vision-in-the-loop segment: the agent generates a terminal program, inspects a PNG of its own output, tests multiple regions and zoom levels, and uses visual feedback to improve the result.
Editorial take: The winning agent loop is not “more autonomy”; it is explicit constraints, feedback-rich outputs, environment fidelity, and a human-owned merge bar.
- Start with codebase Q&A before editing (firsthand): Boris Cherny, an Anthropic technical-staff member and Claude Code creator, recommends onboarding with questions about how code is used or instantiated, then asking the agent to inspect Git history and linked GitHub issues; this also teaches what can be one-, two-, or three-shotted versus what needs interactive guidance. He reports that Anthropic’s technical onboarding fell from about 2–3 weeks to 2–3 days, and that roughly 80% of its technical staff use Claude Code daily, including researchers editing and running notebooks. Cherny also says the tool requires no code indexing, keeps code local, and does not train generative models on it.
- Use a plan–execute–verify loop: For large changes, prompt
Before you write code, make a plan, have the agent brainstorm and request approval, then let it choose among file-editing, Bash, and search tools. Provide a verifier—unit/integration tests or Puppeteer/iOS screenshots—so it can inspect its output and iterate; Cherny says two or three UI iterations can move a result from good to almost perfect. For visual work, provide a mock by dragging, pasting, or specifying its file path, and expose a development server for iteration. - Make context and tools reusable: Put shared project guidance in the project-root memory file, including common commands, MCP usage, style rules, architecture decisions, and core files; keep it short, use local memory for personal preferences, and place directory-specific guidance in nested memory files. Check MCP configuration into the repository so teammates inherit the same tools; Anthropic’s apps repository shares a Puppeteer MCP server for end-to-end tests, screenshots, and automated iteration. Configure frequently used allowed tools to avoid repeated approvals while retaining tiered allow/block controls for safety.
- Automate delivery and parallelize work: Cherny describes the shorthand
commit pushas enough for Claude Code to create a branch, follow repository conventions, commit, push, and open a pull request. The SDK/CLI accepts a prompt, allowed tools, and JSON or streaming JSON; Anthropic uses it in CI and incident response, and Cherny recommends treating it like a Unix utility that can consume Git status, GCP logs, or Sentry data. Multiple checkouts or Git worktrees combined with SSH/tmux sessions let power users run isolated agents in parallel. The announced GitHub app enables@-mentioning Claude on issues and pull requests.
- Shell-first harness design: Armin Ronacher describes Pi as exposing mostly Bash; pipelines can search, transform, and add separators in one command, keeping intermediate results out of the context and making execution relatively context-efficient. Codex similarly relies heavily on Bash and
rgfor file discovery, supporting a shell-first, composable approach before adding specialized tools. Pi’s appeal came from being minimal but user-extensible; Ronacher notes that Claude Code later reduced its tool count and OpenCode 2 is plugin-based. Interleaved system messages in current state-of-the-art models now enable deferred tool loading, making on-demand tool exposure possible. - Firsthand local workflow and environment lesson: Ronacher says most Arendelle engineering agents still run locally; persistent work runs on a desktop Linux machine over SSH, some GitHub Actions can run Pi, and agents are used for system investigation and repository reports—not only code generation. In his setup, the Linux machine runs tests at about half the speed of his Mac. He also examined a cloud desktop-agent environment where PostgreSQL was never started, so database tests did not work and were mocked; a controlled machine reached over SSH has worked better for day-to-day engineering. Multi-agent concurrency creates an environment bottleneck: seven agents may require seven databases, Kafka clusters, and other service instances, while a fresh cached environment may still take roughly seven minutes to bootstrap.
- Durability and ROI caveats: Ronacher identifies portable suspend/resume as unsolved: server-side compaction can make sessions nonportable, and current coding harnesses are not yet durable enough to continue without a human in the loop; he favors giving agents explicit access to manipulable data and databases rather than relying on generic “memory.” He reports no compelling company-level productivity evidence despite noticeably higher code and commit volume, and says side projects appear to be benefiting more clearly than enterprise rollouts—an argument for measuring completed outcomes rather than token spend or commits. He points readers to
pi.devandarendel.com.
- DwarfStar + DeepSeek Flash v4.1: Salvatore Sanfilippo is adding DwarfStar support for DeepSeek Flash v4.1, whose encoder/decoder layout enables encoder-side prefill and KV-cache projection to the decoder. Its total size is roughly twice that of DeepSeek v4, so full residency requires two machines.
- Reproducible local setup and performance: He ran a 2-bit quantized model across two MacBook M5 Max systems with 128 GB RAM each, split 50/50; decoding reached about 29–30 tokens/s and prefill about 700–800 tokens/s. The quantization used 2-bit rotated experts, IQ2 XXS for the transcript’s “app and gate” layers, and Q2K for down projection, but he had not benchmarked the quantization yet.
- Actionable vision-in-the-loop coding workflow: He had the model create a Mandelbrot C terminal program, then iteratively requested Unicode half-block rendering, RGB foreground/background escapes, color-support detection, and a no-color fallback. He used PNG/image inspection to verify the rendered output and tested multiple regions and zoom levels; he identified visual feedback as the key reason this local model produced unusually strong results.
- Adaptive reasoning and memory trade-offs: DeepSeek Flash v4.1 exposes a smooth 0–100 thinking-strength control that can be changed during a session: start low for speed, raise it when the model reaches a difficult step, then lower it again after the obstacle is cleared. On one MacBook, a 90 GB expert cache enabled SSD streaming at roughly 15 tokens/s—about half the full-residency setup—while smaller caches trade speed for memory headroom; Sanfilippo considered the result still usable.
- Availability: He planned to push the DwarfStar implementation and publish the model quantizations so others could download and reproduce the setup.
- Firsthand Cursor/Neovim workflow: TJ demonstrated a project he had been working on for fewer than 10 days, with Cursor chats accessible inside Neovim; the interface can open existing chats, send new messages, and interact with them. He also ran the Cursor SDK as a daemon and exposed a browser view of the chat, reporting that the views stayed synced so the conversation could continue across surfaces.
- Fast-iteration architecture: The GUI uses a Rust layer built with Zed's GPUi project, while Bun/TypeScript handles widgets and overlays that can hot-reload without recompiling the editor. TJ's stated cleanup pattern is to rewrite frequently reused, stable JavaScript widgets in Rust rather than keeping them permanently in the scripting layer.
- Agent-output handling: The GUI and Neovim edit the same underlying buffer live, while the preview renders tables, checklists, highlighted code, images, and sequence diagrams—formats the speakers specifically associate with LLM-generated content.
- Integration caveat: The Linear interface could display issues and mark them done, but editing was untested and webhook-based updates were not implemented; external status changes required a refresh and did not appear automatically.
- Addy Osmani recommends agreeing on the outcome, definition of “done,” constraints, non-touch areas, and whether to refactor or reuse before letting Claude work; lengthy planning is not always necessary with the latest models, but bad changes should be rejected before they become PRs.
-
Give Claude an executable verification loop: specify the exact build, test, and lint commands; turn recurring review failures into reusable skills such as
/verify,e2e, and schema checks; run them before opening a PR and use/code-review. When Claude misses, encode the lesson inCLAUDE.mdor a skill instead of silently fixing it by hand; escalate effort/model quality or have Claude pay down the resulting technical debt if needed. - Keep the human responsible for design and the quality bar, scaling review intensity to blast radius: low-risk throwaway code may be treated as a black box, while production code—especially code touching money, authentication, or user data—needs a higher bar than human-written code. The quoted @bcherny guidance describes Anthropic using lint rules, tests, Claude-driven end-to-end tests, daily Claude-powered fuzzers, automated code and security reviews, and automated refactoring as production guardrails; it also recommends trying the latest frontier model (named there as Opus 5 or Fable 5.1) and increasing effort to high or xhigh when quality is insufficient.
- Simon Willison reports that ChatGPT Work and GPT-6 Astra in “Max” mode can take an address and generate a 5K/10K circular running route using OpenStreetMap data.
-
In a follow-up, he says ChatGPT’s
visualizeskill produced a fragment of HTML using D3 to draw both the map and the overlaid route; the referenced skill is documented here.
- Geoffrey Huntley reports a firsthand Astra workflow: the agent discovered that Blender was already installed and then “vibe coded up the protagonists.” This happened seven hours into a project rebuilding Australia at 1:1 scale in Unreal Engine from ArcGIS data sources. The practical pattern is to let the coding agent inspect and reuse available local tools within a larger generation pipeline.
- Cognition announced SWE-2, claiming it is its closest model yet to the frontier: on leading evaluations, it reportedly performs on par with recent frontier models at up to 70% lower cost. Cognition attributed the result to scaling reinforcement learning to multiple trillions of parameters and refining its training recipe to improve the capability–cost tradeoff.
- Kent C. Dodds amplified the release and said Cognition was offering 50 free Devin Max Plans; applicants were asked to reply with what they would do with the free tokens, with winners to be notified within 24 hours. This is a vendor-reported model comparison and trial offer, not a firsthand workflow or independently detailed benchmark.
Simon Willison reports a firsthand ChatGPT Work workflow using GPT-6 Astra (Max): he prompted it, “I live at
Paul Ford offers a contrarian caution on AI-assisted coding: AI can write “very good software,” but it also makes it easier for people to perform other roles poorly. He argues that cutting-edge software still requires humans to think and work together across complementary crafts, even as broader access to coding makes poor implementation easier.
DHH describes a human-in-the-loop workflow for Omarchy’s PR backlog: at 2,200 PRs and nearly 100 new submissions per day, agents can assist but humans are still needed for triage. Omarchy Triage is intended to consolidate PRs, remove duplicates, and prepare submissions for consideration, while user-experience decisions remain human-owned. The desired merge unit is a trusted cluster or batch of fixes reviewed both by agents and manually, allowing whole tranches to be merged into core.
- In an Astra quality update, @thsottiaux reported three concrete agent-reliability failures: skills written for earlier models could trigger too often or prevent the model from checking its work; an opt-in context-management experiment could cause early stops or replies to older messages and was disabled after an estimated 4,000–5,000 users were affected; and misconfigured engines degraded quality for a long tail of traffic and were removed.
- The fixes targeted more consistent follow-through, better tracking of the latest user message, and stronger checks during execution; the associated reset was subsequently reported as fully propagated.
- @thsottiaux reported Astra agent-quality regressions caused by legacy skills triggering too often or preventing self-checks, an opt-in context-management experiment that led to early stops or replies to older messages (estimated to affect 4–5k users), and misconfigured engines that degraded quality for a long tail of traffic. The team disabled the context experiment and removed the problematic engines.
- Following those fixes, Astra reported more consistent follow-through, better tracking of the latest user message, and stronger checks during execution; a reset was scheduled for the same day. This is a firsthand product-team incident report rather than an independent benchmark.
- Riley Brown’s current firsthand setup: He is experimenting with cloud agents including GrokBot, GPT Work, Meta Muse, and Claude Cowork, but is not committing to one because the best cloud-agent configuration—especially for business—remains unclear. His practical default is a 48GB Mac running Codex + Astra: he remotely controls Codex from a phone, iPad, or lightweight laptop; keeps required browser accounts signed in; and gives it access to an external video drive plus Notion and Google Drive.
- Brown reports that Codex can operate advanced desktop software such as DaVinci Resolve and Premiere. He considers this Mac-based setup more powerful and predictable than OpenClaw, with the main trade-off being high token consumption.
Theo reports a contrarian qualitative comparison: the human-written code he has encountered is “much worse” than AI-generated code from Fable and Astra. The post provides no workflow, evaluation criteria, benchmark, or production context, so it is a signal to investigate these agents rather than a reproducible technique.
@reach_vb reported a reset rolling out to all Codex and ChatGPT Work users after quality issues involving skills that over-triggered or blocked self-checks, context management that caused early stops or stale replies, and misconfigured engines that degraded output quality. The underlying update estimated that roughly 4–5k users were affected by the context-management experiment.
DHH describes Omarchy as a “beautiful, fun & agentic Linux system” and recommends a hands-on onboarding tactic: buy USB sticks, put Omarchy on them, and give them to others so they can experience the system directly.