Activity for Coding Agents Are Becoming Managed Loops

Coding Agents Are Becoming Managed Loops

Addy Osmani’s loop-engineering playbook, faster agent execution, and new handoff, context, and cost-control primitives point to the same shift: the unit of leverage is now the supervised system around the model.

LangChain

Elevate

Matthew Berman

🔥 TOP SIGNAL

Stop treating the coding agent as a single conversation. Addy Osmani’s loop-engineering practice is a supervised fleet: 5–10 agents a day, usually about five concurrently; he fully delegates only bounded tasks with explicit stopping conditions, and watches work touching authentication, security, or finance closely. He explicitly uses one sub-agent to draft and a separate one to verify.

The important caveat is operational: /goal’s evaluator checks whether hard rules appear in the transcript, not whether the implementation is good. Automate execution; keep taste and judgment as a human gate.

⚡ TRY THIS

Turn a recurring queue into a loop → goal pipeline. Start with Osmani’s concrete pattern:
```
/loop every 24h "Check GitHub for issues labeled 'bug'. If one exists, use /goal to implement a fix until all local tests pass and push the branch."
```
Use deterministic finish lines—test counts, scores, or explicit thresholds—rather than “make it good.” For unattended recurring work such as bug reports, triage, migrations, and dependency upgrades, route routine work to smaller, faster models and reserve the strongest model for judgment calls.
Install a verifier, not just a better prompt. For UI changes, make the agent start the dev server, interact with the change, capture before/after screenshots, require zero new console errors or warnings, run a Chrome DevTools MCP performance trace and Core Web Vitals audit, and restart the checklist from step one after any failure. Keep the verifier separate from the implementer.
Fork context before it sprawls; make evidence part of the PR contract. Kent C. Dodds says he routinely tells one agent to spin up a new agent conversation so the original does not get sidetracked, with the necessary context transferred. Peter Steinberger’s OpenClaw team shares agent sessions as URLs and added an AGENTS.md instruction requiring videos on PRs that change UI state. Replicate the pattern: hand off branches of work to fresh sessions, share the session URL, and require a visual artifact for UI-state changes.

📡 WHAT SHIPPED

Cursor officially joined SpaceXAI. Cursor says its acquisition closed and that it will work on Grok Build, Grok Bot, Grok API, Cursor, and more. Matthew Berman, after using GrokBot for about a week, reports a deliberately simpler agent surface: every thread is an individual agent, plugins connect Slack, Google Docs, and email, and agents can converse while preserving their histories.
GPT-5.6 Sol Ultrafast entered preview. OpenAI says the mode runs at up to 14× the speed and is initially available through the API to a select customer group. Berman’s firsthand test cut a financial-terminal dashboard from 12:20 to 1:50; he expects to reduce his usual 10-agent parallelism to two or three because context switching becomes less valuable, while tool calls and CPU—not model thinking—become the bottleneck.
OpenWiki turned repository documentation into an agent-maintained context layer. The open-source project’s design uses self-contained fragments, predictable headings, context-window-conscious formatting, and OKF metadata for filtering and retrieval. openwiki init configures the keys, model, and repo instructions, then writes or modifies AGENTS.md/CLAUDE.md and a daily GitHub Action; updates inspect git history, skip unchanged repos, and open a PR with refreshed docs. It is MIT-licensed, available through npm, and supports roughly 10–15 providers. Early DeepSuite results were 7–8 successful tasks out of 20 without the wiki versus 9–10 with it, alongside fewer tool calls and lower token consumption; the presenter calls the results early.
LangSmith’s LLM Gateway put spend control in front of the model call. The walkthrough shows one endpoint and provider-agnostic routing, with rate and spend limits enforced before requests leave the organization; integration requires changing the base URL and API key rather than request/response handling. When a cap is reached, the gateway returns a catchable policy error and the organization is not charged, while the usage view records model, key, tokens, and cost.
Omarchy Quattro released. DHH announced the release and says Quattro uses agents as bug reporters to produce fewer but materially better reports—an interesting intake loop for open-source maintainers, though the post supplies no benchmark.
Claude provenance is moving into code-adjacent output. Anthropic says future Claude models will watermark generated text for EU AI Act compliance; it claims the mark is reader-indistinguishable, adds no hidden characters or tokens, and carries no identifying information. Its explanation says exact code tokens generally leave little room for watermarking, but arbitrary choices such as comments can be marked; supported PNG, JPG, and SVG files receive signed C2PA metadata, with a detection API planned.
Open-weight routing widened. Berman reports DeepSeek v4 Pro at 87.9 on Terminal Bench, just behind the top Sol/Fable results, with cache-miss input priced at $0.66 per million tokens and cache-hit input at $0.02; he places GLM 5.3 at 66.9 on deepsui and Meta’s 30B Muse Glimmer at 51 on Terminal Bench for on-device use. Treat this as a practitioner snapshot, not a universal leaderboard.

🎬 GO DEEPER

Matthew Berman — “AI News: ChatGPT Ultrafast, Grok 4.6, 3 New Open-Source Models, and more!” — Watch the Ultrafast/Cerebras segment for the 1:50 versus 12:20 comparison and the shift from “run more agents” to “remove the context-switching tax.”

Building Docs for Agents, Not Humans: Inside OpenWiki — The useful section is the implementation loop: generate structured fragments from repo history, update them on a schedule, and merge the resulting PR; the early evals are promising but appropriately modest.

Keep model costs in check with LangSmith LLM Gateway — A compact design reference for centralizing keys, blocking over-budget calls before billing, and keeping a live per-team audit trail without rewriting each agent integration.

Editorial take: The durable coding-agent advantage is no longer a clever prompt or a single frontier model; it is a supervised loop with measurable completion, an independent verifier, and context that can be handed off cleanly.

Coding Agents Are Becoming Managed Loops

Research extraction

Direct answer: Anthropic's explainer describes the watermark only in general terms about "text" and "code" — it never names "Claude Code" — and states that code is generally less watermarked because much of it must be exact. Claimed user-visible and technical effects: the watermark is reader-invisible, adds no tokens or characters, has negligible speed impact, costs nothing extra, and carries no identifying information.

Scope and driver: Future Claude models will generate watermarked text; the change is applied globally at launch because Anthropic "doesn't yet have a durable way to scope it by region," and is intended to comply with the EU AI Act (EU Code of Practice on Transparency of AI-Generated Content, signed July 2026 with ~190 signatories). The watermark is only applied when Claude was involved in processing the content or file.
Mechanism: A version of Google DeepMind's SynthID-Text approach (same design family as Scott Aaronson's 2022 proposal). Next-word choices remain random, but the randomness source is the key plus preceding words instead of an arbitrary random number generator; a key holder can check the sequence and assign a probability that the text was Claude-generated.
Claimed technical effects: No practical impact on output quality or content; internal testing found no impact on content, creativity, or readability; no extra tokens are produced (so serving cost is unchanged); watermarking has a negligible impact on model speed. Nothing is added to the text and there are no hidden characters.
Claimed user-visible effects: Watermarked and unwatermarked text are indistinguishable to readers; the watermark carries no identifying information and cannot be traced to a specific person, organization, or chat.
Limitations: It only answers "What is the likelihood this was partly written by Claude?" — it cannot confirm human authorship or attribute text to another AI; detection is unreliable on small samples and sparser on factual passages where few equivalent word choices exist; lightly edited or proofread text may have too little watermark to detect, while a complete rewrite removes it.
Code output: Where an exact output is required (e.g., "2 + 2 ="), the watermark isn't applied; code, "which in very many cases has to be exact," generally has less watermarking than other text. The watermark can be used where an arbitrary choice exists inside code, such as comments, with "by definition" a negligible effect on the actual code produced. Gap: the article never mentions Claude Code by name, so its coverage of Claude Code specifically is unstated.
Detection tooling: Anthropic says it will "soon" offer a watermark detection API, with implementation details still being worked out.
File provenance (separate from watermarking): For supported file types (e.g., .png, .jpg, .svg), Claude attaches a content credential — a small, cryptographically signed note in the file's metadata using the open C2PA standard. Nothing in the file changes (it is not embedded or hidden), the credential only says Claude was involved, and it contains no identifying information.
What the watermark proves: Only that Claude was likely involved with the content at some point; it cannot distinguish "Claude wrote this" from "Claude heavily edited this," and it does not change ownership or legal responsibility.
Other coverage: Translations carry a watermark because every word is Claude's; the EU law includes a transition period for models launched before August 2, 2026, with watermarking for those models rolled out "over the coming months."

Gaps/uncertainty flagged: The article is a forward-looking explainer of stated intent, not a release note; it gives no launch date, model list, or detection-API timing, and its code discussion is generic rather than Claude Code-specific.

How Claude's text watermarking works

Matthew Berman

youtube

Matthew Berman (AI YouTuber; firsthand for the speed mode and Grokbot, secondhand for Anthropic) recaps a big week for coding-agent tooling.

ChatGPT's 'ultra fast mode' runs GPT-5.6 SOL on Cerebras chips — OpenAI partnered with Cerebras months ago — at ~14–15x speed: his demo built a financial-terminal dashboard in 1m50s vs 12m20s on regular SOL . He tried the preview and says the bottleneck shifts from model thinking to tool calls/CPU, pushing work toward cloud agents . Workflow takeaway: he currently runs ~10 agents in parallel (each ~30 min, sometimes 60–90 with Codex) and will cut to 2–3 concurrent agents now that speed removes the need for parallelism and its context-switching cost .
Per Berman, Cursor is now formally part of SpaceX AI (which also owns Grok). xAI released Grok 4.6 — near-frontier for coding (just behind GPT-5.6 SOL and Fable 5), $2/M input, $6/M output, fast — plus Grokbot, a simplified coding agent that hides code and thinking, requires no model/effort selection, treats every thread as its own agent, has plugins (Slack, Google Docs, email), and lets multiple agents converse while storing their history. He calls it 'OpenClaw for a broader audience' and has already moved many workflows to it .
Three open-source coding models shipped in one week, tracked on Terminal Bench — which Berman calls the most accurate benchmark for real coding-agent use : GLM 5.3 (large jump over GLM 5.2, still behind the frontier) , DeepSeek v4 Pro (87.9 Terminal Bench, 'barely behind' Sol and Fable) , and Meta's 30B Muse Glimmer open-weights model for on-device/desktop-GPU use (Terminal Bench 51, not frontier) . DeepSeek v4 Pro pricing: ~$0.66/M input on cache miss and ~$0.98/M output off-peak (spoken as '$98'), ~2x during peak, and $0.02/M input on cache hits — cheap long-context agent runs .
Anthropic is adding a hidden, key-based watermark to Claude output (undetectable to readers, for EU AI Act Article 52 transparency) with future Claude models; for coding it attaches only where Claude makes arbitrary choices, e.g. code comments, with negligible effect on produced code — per Anthropic's blog, read by Berman's editor .

AI News: ChatGPT Ultrafast, Grok 4.6, 3 New Open-Source Models, and more!

Theo - t3․gg

youtube

Anthropic is watermarking all Claude output, including code: Claude models launched in the EU on/after Aug 2, 2026 carry machine-readable markings at launch (embedded text watermarks plus digitally signed provenance metadata on files), and older models will also be marked. It applies everywhere Claude is used — API, platform, Claude Code, Claude Cowork — at model level, so marks travel with copy-pasted text and "may persist through some editing." This is Anthropic's compliance with EU AI Act Article 50 (the transparency requirements are legal obligations; code-of-practice adherence is voluntary) .
Direct impact on agent workflows: Anthropic plans a text-detection API so third parties can test whether text came from Claude — e.g., check whether a PR was generated by Claude Code. Files Claude creates or touches (SVG, PNG, JPEG) get signed C2PA provenance metadata that signals Claude processing and tampering; C2PA marks can be stripped but not faked. Small "assistive" AI edits (grammar cleanup, minor corrections) are exempt from marking .
Evasion is trivial, demonstrated firsthand: re-exporting as JPEG, re-encoding, resizing, or a 1% sharpen destroys image watermarks; text watermarks are stripped by paraphrasing with any unwatermarked LLM or replacing Unicode homoglyphs. Watermark-removal repos already exist — including an agent skill + Python script that removes multi-vendor AI provenance marks from text, PNG, JPEG, SVG, PDF, DOCX, HTML, and MD files (you can have Claude strip Claude's own marks). Theo's verdict: this only catches low-effort copy-paste and bots; determined users just add basic preprocessing or move to cheap open-weight models .
Why text watermarking can't be robust: text has too little entropy to hide data, so schemes bias token sampling (e.g., SynthID scores top-k tokens; detection computes aggregate scores) — cheaper than rerunning the model and avoids false positives for humans who naturally write like LLMs. The EU's interoperability requirement (publish/standardize watermark schemes) contradicts the security-by-obscurity these methods depend on. Theo argues the only durable direction is signing and verifying human-generated content, not detecting AI output .
Attribution: Theo (t3.gg), full-stack TypeScript developer, mixes firsthand watermark-evasion demos with secondhand reporting of Anthropic's docs, the EU AI Office code of practice, and an analysis by "Kishan Godek"; he notes OpenAI's "quiet Unicode trickery" and Google's SynthID are in the same space .

Claude watermarks your code now

Elevate

substack

Addy Osmani (maintainer of open-source Agent Skills, ~80k stars) details his Claude Code loop-engineering practice: he runs 5–10 agents in parallel (usually max 5 concurrently), fully delegating tasks with clear stopping conditions (docs, test-coverage checks) and closely watching work touching auth, security, finance, or complex specs . He notes loop risk is higher on brownfield/bank codebases than an evergreen repo with fewer users .

Primitives:/goal drives a single bounded task until a measurable finish line; /loop reruns a prompt on a timer/interval (like cron) for polling or recurring checks; /schedule runs routines in the cloud. Loops are session-scoped and expire 7 days after creation (Osmani corrected his earlier “3 days”); --resume/--continue restores recurring tasks within that window . Before these primitives, he and others hand-rolled bash loops and experimented with Geoff Huntley’s Ralph loop on personal projects .
Separate drafting and verifying agents: “One sub-agent drafts the change. A separate one verifies it” . His reusable verify-frontend-change skill: start dev server, interact with the change, screenshot before/after, confirm zero new console errors/warnings, run a performance trace and Core Web Vitals audit via Chrome DevTools MCP, and rerun from step 1 on any failure .
Deterministic goal prompt:/goal Refactor the data-fetching layer in Dashboard.tsx until Lighthouse performance score is >= 92 and LCP is under 1.8s as shown by the Lighthouse CLI output. Do not change the public API of any hooks. Each turn must improve at least one reported metric; abort if two consecutive turns show no improvement. Stop after 10 turns. The goal evaluator only checks whether the stated hard rules appear in the transcript — it does not judge quality or taste .
Maintainer loops: On Agent Skills (80k stars, ~80–90 PRs/day): /loop every 1h "Check the GitHub repository for any new open issues. Provide a bulleted summary of their urgency."; combined pattern: /loop every 24h "Check GitHub for issues labeled 'bug'. If one exists, use /goal to implement a fix until all local tests pass and push the branch.".
Claude Code team’s four loop types (quoted): manual agentic loop; goal-based loops (best with deterministic criteria like test counts or score thresholds); time-based loops (e.g., /loop 5m check my PR, address review comments, and fix failing CI); and proactive routines triggered by events/schedules with no human in real time — best for bug reports, triage, migrations, dependency upgrades; route routine work to smaller/faster models, keep the most capable model for judgment calls .
Advanced unattended composition:/schedule + /goal + skills + dynamic workflows + auto mode, e.g., hourly check of a feedback channel, triage/action/respond to every report, with a workflow exploring three fixes in parallel worktrees and a judge adversarially reviewing them .
Caveats: Osmani almost merged agent-produced PRs (competitor-gap research) without reading implementations closely and warns against delegating taste/judgment — delegate the task, then verify it meets your bar . Vague goals like “until this UI design is good” are poor loop fits . A loop spinning in place shows the same command repeated a third time with no change in result — stop .
Tool note: Sponsor Trigger.dev (open source, TypeScript, Vercel AI SDK) shipped a chat agent that runs a multi-turn conversation as one durable task — survives refreshes/redeploys/crashes, pauses for human approval, resumes in place .

Practical Loop Engineering

Simon Willison

Gemini 3.7 Flash was announced with coding improvements: strong gains over 3.6 Flash in debugging and issue resolution, better at designing web layouts/apps with fewer prompts, and improved reasoning for business workflows. Available in Antigravity, with API access in Google AI Studio and Android Studio; Google AI Pro/Ultra subscribers can use it in Gemini Spark in the Gemini app .

Simon Willison flags a pricing caveat: 3.7 Flash's introductory price is scheduled to double on December 31, 2026, which he calls "really weird" given 3.6 Flash launched just three weeks earlier .

Debugging lesson from Simon Willison: he initially suspected an SVG bug in Gemini 3.7 Flash when output rendered incorrectly in Firefox and Chrome, but it turned out his own software was stripping "unsafe" attributes that broke the SVG — a reminder to check your own pipeline before blaming the model .

🔵 It shows strong gains over 3.6 Flash in key coding tasks like debugging and issue resolution. 🔵 It’s better at designing more functiona… The "introductory pricing" for the 3.7 Flash model is really weird It's scheduled to double in price on December 31, 2026, but who would … Important correction: this was entirely my bug, it was NOT a bug in the SVG output by Gemini 3.7 Flash My own software was stripping some…

swyx

@tszzl argues that major AI companies should offer a real-time priced API product, since AI demand varies over a day/night curve and the industry is broadly capacity-crunched; he notes that agents make dealing with variable pricing, batching, and projecting total costs easy . @swyx quote-tweeted this with the comment "damn deepseek moves fast on roon tweets" and an image .

the major ai companies should commit to a real time priced API product. ai demand varies wildly over a day/night curve and the industry i… damn deepseek moves fast on roon tweets ![](https://pbs.twimg.com/media/HPsjv6ZaMAEbcD4.jpg) [https://x.com/tszzl/status/2088060528988201…

Simon Willison's Weblog

simonwillison

Doug Turnbull's "Don't classify. Hallucinate!" technique solves LLM classification when the target vocabulary is too large for the context window: instead of feeding all possible tags, tell the model to invent novel, plausible tags that fit an example shape, then use vector embeddings to find the concrete existing tags closest to the hallucinated ones . Simon Willison flags this for his own 1,856-tag blog, where the full vocabulary is too big to present to an LLM in one go . The suggested prompt includes examples of the taxonomy's format — e.g., Furniture / Living Room Furniture / Coffee Tables & End Tables / Coffee Tables, Décor & Pillows / Decorative Pillows & Blankets / Throw Pillows — followed by Here's the query to generate classifications for: and the query itself, such as brown coffee table. The pattern generalizes to any coding-agent or routing task with a large fixed output vocabulary: generate a hypothetical candidate and embed-match it to the ground-truth set.

Don't classify. Hallucinate!

ThePrimeagen

OpenAI announced Computer History in the ChatGPT desktop app: ChatGPT can now remember a user's activity across the apps and websites on their computer, making future interactions feel more personalized and require less explanation . @ThePrimeagen pushes back, saying most people don't want GPT remembering what they've been doing on the internet . Secondhand: ThePrimeagen is commenting on OpenAI's official announcement, not reporting hands-on testing, and his take is a privacy concern rather than a technical critique.

ChatGPT can now remember your activity across the apps and websites on your computer. With Computer History in the desktop app, future in… I don't think most of you want GPT to remember what you've been doing on the internet... [https://x.com/OpenAI/status/2087996496088297746…

DHH

DHH (creator of Ruby on Rails and Omarchy, co-owner/CTO of 37signals) reports Omarchy Quattro installed in 45 seconds on an AMD 9950X3D with Gen5 NVMe, and says he expects to break the 30-second barrier this year .

Omarchy Quattro install in 45 SECONDS on a AMD 9950X3D with Gen5 NVMe. We are absolutely going to break the 30-second barrier this year. …

LangChain

youtube

OpenWiki is an open-source (MIT, npm) CLI that generates and auto-maintains repo documentation built specifically for agents to consume; it supports ~10–15 LLM providers . Setup is intentionally trivial: openwiki init runs a wizard (API keys, model, instruction prompt), then writes a GitHub Actions cron that runs openwiki update daily and injects a pointer into agents.md/CLAUDE.md so agents know when to consult the wiki . The update command checks git history/commits, regenerates docs based on changes, and opens a PR for merging; it skips runs when nothing changed . Docs are markdown structured like Karpathy's LLM wiki, with deterministic OKF YAML front matter (type, title, description, tags, timestamp; OKF 0.2 support coming) enabling filtering, and cross-links so agents retrieve self-contained fragments rather than entire doc sets; context-window efficiency is a priority (e.g., no accidental base64 blobs in tool calls) . Early evals on ~20 Deepsui coding-agent tasks: ~7–8/20 succeeded without the wiki vs ~9–10/20 with it, plus significantly lower token consumption and fewer tool calls/searches; benchmarks are still early . Key correction: building docs only for agents was wrong — human engineers also read them, so they added diagrams (sequence/state/flow) which also may help agents . Roadmap: dedicated search/retrieval tools for the wiki (beyond the agents.md pointer) already show gains in internal, unmerged evals; better prompting for larger repos . Firsthand account from the project builder, presented on the LangChain channel.

Building Docs for Agents, Not Humans: Inside OpenWiki

ThePrimeagen

ThePrimeagen predicts that for CI to be mostly replaced with agents, agents need to become 1000x cheaper and 10x faster .

Prediction: for CI to be mostly replaced with agents requires 1000x cheaper and 10x faster agents

Jediah Katz

Cursor's acquisition by SpaceX is official: the company announced it will join the SpaceXAI team to make Grok the world's most useful AI, with focus areas including Grok Build, Grok Bot, Grok API, Cursor, and more.

Cursor is now part of [@SpaceX](https://x.com/SpaceX). Today, we have officially closed our acquisition. We will join the [@SpaceXAI](htt…

LangChain

youtube

LangChain's Jacob Lee demos the new LangSmith LLM Gateway for org-wide control of model access and spend: one endpoint routes every request — from coding agents like Codex to internal RAG apps and support bots — through OpenAI, Anthropic, Fireworks, etc., with spend limits and rate limits enforced before a request goes out .
Drop-in setup: no SDK changes beyond pointing at the gateway base URL and swapping the API key; existing request/response handling stays untouched (TypeScript and Python examples shown) .
In the live demo, a routed call generates a LangSmith trace; hitting the configured limit returns the catchable error "request has been blocked by my gateway policy," so the org never sees the charge .
Spend limits can be set centrally at the org level or granularly per API key, workspace, or org via the Cost Controls page; the Usage page provides a live audit trail of which model, key, tokens, and cost per team, replacing invoice reconstruction .
Motivating problem: teams holding their own keys for support bots, RAG apps, and coding agents cause tripled token spend with no clear answer to "which agent burned through it" — the gateway gives a single point of control and revocation .

Keep model costs in check with LangSmith LLM Gateway

Riley Brown

Riley Brown, who helps businesses implement agents, says xAI's GrokBot is behind Codex/GPT Work overall, but its biggest innovation is personifying chat sessions: a GrokBot is a named session with a mini system prompt, with Cronjobs/Automations living inside the session while sharing the same skills and plugins. He argues users will go to a purpose-specific session (GrokBot) instead of creating new sessions each time, which keeps things organized.
Teknium (Nous Research) announced Bot Mode for Hermes Agent: an alternative to sessions mode where you have one chat per agent profile ("bot"), and bots can be given jobs, descriptions, profile pics, and can communicate with other bots. It's in a one-day public beta via the Hermes-Bot-Mode plugin (https://github.com/NousResearch/Hermes-Bot-Mode), after which feedback will be incorporated into the main Desktop App.
Riley predicts Hermes is the first agent platform to copy GrokBot's session-based agents, and that "many more will."

I think GrokBot is behind Codex/GPT Work for a lot of reasons, but I will say, their biggest innovation is personifying the chat sessions… Introducing Bot Mode for Hermes Agent. Bot Mode is an alternative to sessions mode, where you have one chat with each agent profile, or "… The first of the agent platforms to copy GrokBots session based agents. I predict many more will. [https://x.com/teknium/status/208800399…

geoff

Cursor Agent may be what pushes @GeoffreyHuntley to upgrade to Grok Superheavy, though he finds the $500/month price "a bit rich" — a firsthand practitioner sentiment with no workflow detail .

tbh, cursor agent might be just the thing that makes me upgrade to grok superheavy though $500/month is a bit rich ugghhh.

Fireship

youtube

Per Fireship's sponsor segment, CodeRabbit launched CodeRabbit Security, a code security agent billed as using "actual reasoning instead of brittle regex rules" . Its security agents are "designed to think like an attacker" to hunt vulnerabilities across the codebase, prioritize risks based on reachability, exploitability, and blast radius, and explain issues in plain English with a suggested fix that can be approved and merged from the diff . It reviews every PR before merge and supports scheduled deep scans across the full codebase; the promo offers 10 free scans . This is vendor marketing in a paid segment, not an independent evaluation.

This new startup can query anywhere you've been...

Kent C. Dodds 🐨

Cursor announced it is now part of SpaceX: the acquisition closed today (Aug 14, 2026) and Cursor will join the SpaceXAI team to help make Grok the world's most useful AI and improve Grok Build, Grok Bot, Grok API, Cursor, and more . @kentcdodds highlighted how tight SpaceX-Cursor collaboration was even before the acquisition finalized .

Cursor is now part of [@SpaceX](https://x.com/SpaceX). Today, we have officially closed our acquisition. We will join the [@SpaceXAI](htt… I think it's pretty awesome how tight their collaboration was even before the acquisition was final. Those guys just move! [https://x.com…

Cursor

Cursor, the AI coding agent, has been acquired by SpaceX; the deal is officially closed, and Cursor will join the @SpaceXAI team to work on improving Grok, Grok Build, Grok Bot, Grok API, and Cursor itself.

Cursor is now part of [@SpaceX](https://x.com/SpaceX). Today, we have officially closed our acquisition. We will join the [@SpaceXAI](htt…

Kent C. Dodds 🐨

Kent C. Dodds (@kentcdodds) says he made another Kody-branded product last night that lets your agent talk to other agents securely, useful for collaboration with partners . He clarifies in a reply that it's another open source product on his GitHub, though no name, repo link, or usage details are given yet . This is a firsthand teaser announcement from the creator.

I made another Kody branded product last night. It allows your agent to talk to other agents securely. Useful for collaboration with part… For the curious, this is another open source product on my GitHub.

Peter Steinberger 🦞

Peter Steinberger (@steipete) added a short instruction to his project's shared AGENTS MD file telling the coding agent to upload videos to each PR that changes UI state, linking the change to a PR on the openclaw/openclaw repo. This is a replicable workflow pattern: use an AGENTS.md instruction so agents attach video evidence for UI changes in PRs .

Added a short instruction to our shared AGENTS MD file to upload videos to each PR that changes UI state. [https://github.com/openclaw/op…

Practical Loop Engineering

Open on addyo.substack.com Open 21 hours ago

1 of 30 highlights

The way that I typically work is I have anywhere between five and ten agents working at the same time in parallel. There are going to be some tasks that I’m very happy to delegate fully to agents, as long as I have a very clear idea of the stopping conditions and the constraints around them. And then there are going to be some tasks where I am going to want to keep a closer eye and code-review what the agent is doing.

Now within that, you’ve probably heard about loop engineering. I talked about it a couple of months ago when I wrote a big blog post about it.

A loop is an autonomous, self-correcting feedback cycle where an AI agent repeatedly acts, tests its results and adjusts its approach until a specific goal is met

A quick message from our sponsor:

Make AI agents survive contact with production using Trigger.dev (opens in new tab). A demo chatbot is a few lines. The same agent in production has to survive users refreshing, you redeploying mid-conversation, servers crashing - and it can’t take irreversible actions without a human in the loop. This issue’s sponsor, Trigger.dev (opens in new tab), just shipped their chat agent to close exactly that gap. It runs a whole multi-turn conversation as one durable task - so a chat that’s mid-stream survives refreshes, redeploys, idle gaps, even crashes and picks up right where it left off.

There are now basically two core primitives you can think about. In Claude Code you have a goal (opens in new tab) primitive, which can drive a single bounded task forward until you’ve got a particular goal, like a measurable finish line that’s been met. And then loop (opens in new tab) reruns on a timer or a fixed interval, so you can use it to kind of schedule changes.

Before the primitives were primitives

I remember back before we had primitives baked into Claude Code and Codex, loop engineering was heavily about setting up your own bash loop, a hand-rolled thing. That’s how I approached it. And you might remember earlier in the year, a number of us were playing around with the Ralph loop (opens in new tab) by Geoff Huntley. We were experimenting, we were sharing our workflows, we were sharing what worked and what didn’t, but it was largely on some of our personal projects where, if we ran into a wall, it didn’t really have a big cost to us because it was on personal projects.

And as we’ve tried to see what patterns, what aspects of loop engineering are now a little bit more baked, I think we have a clearer idea of how you babysit it. I can now largely rely on the output of the primitives in Claude Code and Codex. We’ve come a little way. But at the same time, you need to be very diligent, because loop engineering where you kind of leave it sitting alone, and you haven’t really thought about whether the end goal or the constraints have been well defined, can leave you in a problematic state. This is why there’s nuance when deciding to use it for an evergreen codebase without users or as much historical complexity vs. say a brownfield bank codebase.

How the Claude Code team frames loops

The Claude Code team published their take on four kinds of loops and it lines up with how I use the primitives (their write-up (opens in new tab)). Before we get to it, here’s my quick summary:

On the Claude Code team, we define loops as agents repeating cycles of work until a stop condition is met. We categorize a few different types of loops based on: how they are triggered, how they are stopped, what Claude Code primitive is used, what type of task is most appropriate for each. Not all tasks require complex loops; start with the simplest solution and use these patterns selectively.
Every prompt you send starts a manual loop with you directing each turn. Claude gathers context, takes action, checks its work, repeats if needed, and responds. We call this the agentic loop. For example, ask Claude to create a like button. It reads your code, makes the edit, runs the tests, and hands back something it believes works. You then manually check the work, and write the next prompt.

Their write-up walks each rung.

On goal-based loops:

Sometimes, a single turn is not enough, especially for more complex tasks. Agents do better when they can iterate. You can extend how long Claude keeps iterating by defining what done looks like with /goal. When you define the success criteria, Claude doesn’t have to make a determination on what is “good enough” and end the loop early. Each time Claude tries to stop, an evaluator model checks your condition and sends it back to work until the goal is met or a number of turns you define is reached. This is why deterministic criteria, such as number of tests passed or clearing a certain score threshold, are so effective. For example: /goal get the homepage Lighthouse score to 90 or above, stop after 5 tries.

On time-based loops:

Some agentic work is recurring: the task stays the same and only the inputs change. For example, summarizing Slack messages every morning. Other work depends on external systems, and a simple way to interface with one is to check it on an interval and react to what changed. For example, a PR which may receive code reviews or fail CI. For these, you can trigger when Claude runs with /loop, which re-runs a prompt on an interval. For example: /loop 5m check my PR, address review comments, and fix failing CI. /loop runs on your computer, so if you turn it off, it stops. You can move the loop to the cloud by creating a routine with /schedule (opens in new tab).

And on proactive loops, the top rung:

Triggered by: an event or schedule, with no human in real time. Stop criteria: each task exits when its goal is met. The routine itself runs until you turn it off. Best used for: recurring streams of well-defined work: bug reports, issue triage, migrations, dependency upgrades. Managed usage by: routing routines to smaller, faster models and using the most capable model for judgment calls.

Their verification advice is worth lifting whole, because it moves the manual checking into something Claude applies itself:

---
name: verify-frontend-change
description: Verify any UI change end-to-end before declaring it done.
---
# Verifying frontend changes
Never report a UI change as complete based on a successful edit alone.
Verify it the way a human reviewer would:
1. Start the dev server and open the edited page in the browser.
2. Interact with the change directly. For a new control (button, input,
   toggle): click it, confirm the expected state change, and screenshot
   before/after.
3. Check the browser console: zero new errors or warnings.
4. Use the Chrome Devtools MCP, run a performance trace and audit
   Core Web Vitals.
If any step fails, fix the issue and rerun from step 1 - do not hand
back partially verified work.

Goal

The way that I use goal is I use it for building any specific piece of work until it’s provably done. Like for example, you can use a goal to say: make sure that this experience loads in five seconds, keep going until it’s done. And it will continue to use an independent evaluation check to keep checking if the completion criteria has been met. What’s better is to be even more specific about what tooling is being used.

As for real goals that I’ve run to a number, there’s a few things that I’ve done. I’ve used goals for running through GitHub issues: review and close the last 10 issues, or review and move the last 10 issues forward, something like that. And that’s semi-open-ended, right? Or: let’s make this page load 50% faster. Sometimes that works well, sometimes it doesn’t, but it’s really about the experimentation.

Loop

Loop is a little bit more of a scheduler, so it keeps an eye on something or repeatedly executes a pattern on some cadence. So think of it a little bit like a cron. It’s best for doing things like polling logs or monitoring external states. You could use it for potentially checking in. If there are repetitive tasks you find yourself doing on some cadence, loop is pretty good for that.

What I delegate, and what I watch

For me, I use probably between five and ten agents every day. Very typically I’ll max out at about five concurrently. And some of those tasks might be ones that are a little bit safer. So maybe it’s, hey, I implemented this feature, go write the documentation for it. Or go double check that we have sufficient test coverage. Or something in that vein. If I’m working on a more complex problem, or something where I know that even if I’ve given it a good spec, or what I think was a good spec, and I’ve tried to give it some stopping conditions, there is still a reasonable chance it may not get everything right, I would try to watch it more closely. If the task involves anything just a little bit sensitive, whether it is I’ve given this access to a system, or whether the feature happens to touch authentication, or something related to security or finance, I’ll definitely be watching that closely.

Generally speaking, I do think we’re going to get to a place where folks are increasingly comfortable with delegation, as long as they’re able to have these clear ways of verifying that their goal or their stopping condition has been met. But you do still need to take a look at the code, at the thing that’s being generated, to make sure that it’s meeting your mark.

The other habit that matters here is not letting the agent that did the work decide the work is good. One sub-agent drafts the change. A separate one verifies it.

Sometimes an agent can be confident about something, and a verifying agent can catch things that they weren’t necessarily expecting. Like if it thinks that the baseline performance of an experience it’s generated is actually fine, and it’s only evaluating performance based on desktop, but you’re actually caring about the experience on mobile. That might mean the agent is being very confident about one dimension of the problem, but not the other.

And I learned this one the hard way. I was curious to figure out: is there something that we’re missing that we haven’t gotten direct feedback on from our users, either in an issue tracker or in a comment somewhere? And so I asked it to go and take a look at some of our competitors, and put together a list, and some PRs, not pushed, but some PRs locally, of what solving some of those gaps might look like. And I almost pushed some of those changes. But I didn’t actually look at them closely enough. I read through its research, but I didn’t look at the implementations closely enough. So I delegated the task, but I was close to delegating the judgment as well. Now, when I actually looked through the changes, what I realized is that it would introduce a lot of additional complexity for our users, for, I think personally, not all that much gain. And so I feel like you need to sometimes check yourself, that you are not delegating the taste and the judgment to your agent. You’re delegating the task, and then you are actually checking back that it’s meeting your bar.

The evaluator sitting behind goal is not that checker, by the way. It doesn’t look at the content to see if it’s good or bad in any way, shape, or form. All it does is examine the conversation transcript to see if the hard rules you specified have been met.

/goal Refactor the data-fetching layer in Dashboard.tsx until Lighthouse performance score is >= 92 and LCP is under 1.8s as shown by the Lighthouse CLI output. Do not change the public API of any hooks. Each turn must improve at least one reported metric; abort if two consecutive turns show no improvement. Stop after 10 turns.

The workflow I run every day

One of the workflows that I do every day: I have a popular open source repository called Agent Skills (opens in new tab). We’ve got over 80,000 stars, and up until recently we were getting anywhere up to like 80 or 90 pull requests that we had to review a day. And so every day I would go and I would spend some time checking on this. Now with loop, what you can do is say: well, every 24 hours or every 12 hours, check the GitHub repository for any new open issues and provide a summary of their urgency, or provide a first pass review, or anything like that.

/loop every 1h "Check the GitHub repository for any new open issues. Provide a bulleted summary of their urgency."

Combining loops and goals

Now you can also sort of combine loops and goals. So you use loop to schedule a check, and then goal to solve the problem. So you can say something like: loop for every 24 hours, check GitHub for issues labeled bug. If one exists, use goal to implement a fix until all local tests pass and push the branch.

/loop every 24h "Check GitHub for issues labeled 'bug'. If one exists, use /goal to implement a fix until all local tests pass and push the branch."

But also keep in mind that goal has got some limitations around just how much you can sort of cram in there.

Their write-up also has a composed example that shows where this is all heading:

The primitives above, along with other Claude Code features like auto mode (opens in new tab) and dynamic workflows (research preview) can be composed into a loop for long-running work. For example, to handle incoming feedback, you can use: /schedule (research preview) to run a routine that checks for new reports, /goal to define what done looks like, and skills to document how to verify it. Dynamic workflows (opens in new tab) to orchestrate agents that triage each report, fix it, and review the fix. Auto mode so the routine runs without stopping to ask for permission. Putting it together, a prompt could look like this: /schedule every hour: check the project-feedback channel for bug reports. /goal: don’t stop until every report found this run is triaged, actioned, and responded to. When fixing a bug, use a workflow to explore three solutions in parallel worktrees and have a judge adversarially review them.

What the triage system actually does

Inside the PR triage, when I have loops and goals working together for me, what I end up having is a system that allows me to really continue accepting PRs and issues, being able to stay on top of what is coming on my plate every day, and especially being able to cross-reference. That’s been a really big deal for me. If I want to work on a particular goal of, hey, we’re going to be redoing this part of the system, and I need to make sure that any issues that happen to touch it are closed as a result of this rework, or we’re not stepping on anyone else’s toes, I can make sure that that’s well defined.

Scheduled tasks are really useful for regularly just reviewing new PRs and closing things that clearly don’t fit. One good stopping condition, for example: we have a set of contribution guidelines, and our contribution guidelines include things like, hey, we currently don’t accept translations.

And it’s not that we don’t care, it’s that they’re difficult for us to maintain, because we don’t speak all the languages often coming in. And so if we tell it, close any issues or close any PRs which happen to touch that aspect of our contribution guidelines, that’s something that can do really well when it’s on that schedule. And so it reduces the overall batch of things that we need to review.

What loops don’t buy you

I’m often asked what loop engineering is not a great fit for. Generally speaking if you don’t have a clear idea of what the end-state/done/good means for your completion, it may not be the right pattern for your work. For example, a vague goal would be “keep going until this UI design is good”. What does that mean? Good to who? How is it being evaluated? Tasks that require human taste, subjective design, or open-ended creative exploration aren’t a good fit. When you have a pretty clear idea of the goal, I think loops are a good option to consider.

A final message from our sponsor:

Still hand-rolling durable agents? Trigger.dev (opens in new tab)’s new chat agent (above) makes a multi-turn AI conversation a single durable task - survives redeploys and crashes, pauses for human approval, resumes exactly where it left off. Open source, TypeScript, drops into the Vercel AI SDK. Check them out (opens in new tab).

The fine print

One classic sign that you’ve got a loop spinning in place is the same command being tried over and over without any change in the result. Give the same command a third time with no change from the second and it’s probably time to stop.

One bit of fine print worth knowing. Recurring loops expire seven days after creation. I’d been telling people this was three days. It’s seven. And loops are session-scoped, so they stop when you start a new conversation - though resuming that session with –resume or –continue brings back any recurring task still inside its seven-day window. If you need something that outlives your session, /schedule runs it in the cloud.

If there’s a check you already run every morning by hand, that’s your first loop. Mine was the pull request pile.

Insights

Elevate https://addyo.substack.com

Primitives:/goal drives a single bounded task until a measurable finish line; /loop reruns a prompt on a timer/interval (like cron) for polling or recurring checks; /schedule runs routines in the cloud. Loops are session-scoped and expire 7 days after creation (Osmani corrected his earlier “3 days”); --resume/--continue restores recurring tasks within that window . Before these primitives, he and others hand-rolled bash loops and experimented with Geoff Huntley’s Ralph loop on personal projects .
Separate drafting and verifying agents: “One sub-agent drafts the change. A separate one verifies it” . His reusable verify-frontend-change skill: start dev server, interact with the change, screenshot before/after, confirm zero new console errors/warnings, run a performance trace and Core Web Vitals audit via Chrome DevTools MCP, and rerun from step 1 on any failure .
Deterministic goal prompt:/goal Refactor the data-fetching layer in Dashboard.tsx until Lighthouse performance score is >= 92 and LCP is under 1.8s as shown by the Lighthouse CLI output. Do not change the public API of any hooks. Each turn must improve at least one reported metric; abort if two consecutive turns show no improvement. Stop after 10 turns. The goal evaluator only checks whether the stated hard rules appear in the transcript — it does not judge quality or taste .
Maintainer loops: On Agent Skills (80k stars, ~80–90 PRs/day): /loop every 1h "Check the GitHub repository for any new open issues. Provide a bulleted summary of their urgency."; combined pattern: /loop every 24h "Check GitHub for issues labeled 'bug'. If one exists, use /goal to implement a fix until all local tests pass and push the branch.".
Claude Code team’s four loop types (quoted): manual agentic loop; goal-based loops (best with deterministic criteria like test counts or score thresholds); time-based loops (e.g., /loop 5m check my PR, address review comments, and fix failing CI); and proactive routines triggered by events/schedules with no human in real time — best for bug reports, triage, migrations, dependency upgrades; route routine work to smaller/faster models, keep the most capable model for judgment calls .
Advanced unattended composition:/schedule + /goal + skills + dynamic workflows + auto mode, e.g., hourly check of a feedback channel, triage/action/respond to every report, with a workflow exploring three fixes in parallel worktrees and a judge adversarially reviewing them .
Caveats: Osmani almost merged agent-produced PRs (competitor-gap research) without reading implementations closely and warns against delegating taste/judgment — delegate the task, then verify it meets your bar . Vague goals like “until this UI design is good” are poor loop fits . A loop spinning in place shows the same command repeated a third time with no change in result — stop .
Tool note: Sponsor Trigger.dev (open source, TypeScript, Vercel AI SDK) shipped a chat agent that runs a multi-turn conversation as one durable task — survives refreshes/redeploys/crashes, pauses for human approval, resumes in place .

Practical Loop Engineering