Stop prompting, start engineering loops

😁 Hello, super humans! The most-quoted line in AI engineering this week wasn’t a prompt — it was “I don’t prompt Claude anymore, I write loops.” The people who built your favorite coding agents have quietly moved past prompting into loop engineering, and the same crowd is already falling into its trap. Let’s dig in.

📰 Quick Signals

• 🧠 AI — The U.S. government issued an export-control directive blocking foreign nationals from Anthropic’s new Fable 5 / Mythos 5; unable to gate access by nationality in real time, Anthropic disabled both models for everyone (Anthropic).
• 🤖 Robotics — Rivian CEO RJ Scaringe revealed a humanoid-robot venture, Mind Robotics, with Rivian as a large minority shareholder and launch customer, and a first product teased within a year (CNBC).
• 💻 Programming — Linear launched agent-run “coding sessions” that turn a bug report into an investigation, a fix, a pull request, and status updates without leaving the issue tracker (Linear).
• ⚡ Electronics — The Semiconductor Industry Association now projects 2026 worldwide chip sales above $1.5 trillion, with AI-data-center silicon alone on track for ~$1.2 trillion a year by 2028 (SIA).
• 📡 Telecom — An MWC 2026 6G initiative pulled Nvidia together with BT, Deutsche Telekom, Ericsson, Nokia, SK Telecom, SoftBank and T-Mobile to push an “open, intelligent, resilient” AI-native 6G stack (Computer Weekly).

🔍 The Big Story: Loop engineering, and the “loopmaxxing” trap

If you write code with AI, the skill that mattered last year — crafting the perfect prompt — is being replaced by a different one: designing the loop the prompt runs inside. That’s a real architecture shift, and it comes with a brand-new way to set fire to your API budget.

What happened: OpenClaw creator Peter Steinberger told developers “you shouldn’t be prompting coding agents anymore — you should be designing loops that prompt your agents,” echoing Claude Code lead Boris Cherny: “I don’t prompt Claude anymore. I have loops that are running… my job is to write loops.” As the idea spreads, a dangerous anti-pattern is spreading with it: “loopmaxxing,” where careless, open-ended automation replaces real software architecture.

The details: Loop engineering turns a model from a call-and-response tool into a participant in an event loop: give it a verifiable goal, then let it observe state, pick an action, execute, check the result, and decide to continue, retry, or stop. Google engineer Addy Osmani’s primitives (Loop Engineering) map the anatomy well — automations (the trigger, e.g. a cron job or /goal), worktrees (isolated branches so parallel sub-agents don’t clobber each other), skills and MCP tools, sub-agents (one drafts, a separate one grades), and external memory (a Linear board or progress file, since context windows clear). Karpathy’s overnight autoresearch loop is the clean version of the idea. The failure mode is “loopmaxxing” — the cousin of tokenmaxxing — where while(true) replaces architecture. Hand a loop a fuzzy goal like “refactor this to be better” with no deterministic exit condition and the agent drifts forever, optimizing hallucinated metrics, burning millions of tokens on retries and context rebuilds, and quietly shipping code no human understands.

🗞️ More News

A fuller roundup across the beat, three per vertical.

🧠 AI

• Meta began unwinding its Manus acquisition after Chinese regulatory pressure, with founders reportedly exploring a buyback (Bloomberg).
• Genspark raised $100M at a $2.6B valuation for its agentic workplace platform, pushing total funding past $645M (Axios).
• Google’s DiffusionGemma brought diffusion-style text generation to the Gemma family, refining blocks of text in parallel instead of token-by-token (Google Developers).

🤖 Robotics

• Boston Dynamics’ production-ready electric Atlas began shipping its first 2026 units, with early deployments at Hyundai and Google DeepMind (Automate.org).
• Figure AI’s BotQ factory hit a production ramp of one Figure 03 humanoid per hour, a 24x jump in under four months (Figure).
• China launched a national program to move 10,000+ humanoid robots from demos into real industrial jobs (eWeek).

💻 Programming

• Xiaomi released MiMo Code, an open-source terminal coding agent with persistent memory, voice input, and Claude Code compatibility (Xiaomi).
• Coinbase debuted an MCP server that lets agents trade crypto and pay for compute or data via the x402 payment protocol (TechCrunch).
• A ProgramBench analysis found “test-driven development” can make coding agents overfit their own weak tests — worse pass rates at higher token cost (report).

⚡ Electronics

• RISC-V pushed toward 25% market share on the back of Meta’s Rivos and Qualcomm’s Ventana deals, a real dent in the Arm/x86 monopoly (eeNews Europe).
• Fortior Technology launched the FU75xx dual-core motor-control MCU, pairing a 32-bit RISC-V core with its 2nd-gen Motor Engine for fast FOC/BLDC control (CNX Software).
• The RISC-V ecosystem gathered in Bologna for RISC-V Summit Europe (June 8–12) — keynotes and sessions spanning AI, automotive, HPC, and embedded (RISC-V International).

📡 Telecom

• AT&T, T-Mobile, and Verizon agreed in principle to form a direct-to-device satellite joint venture, pooling spectrum to kill rural dead zones and back emergency comms (Verizon).
• SpaceX began trading on the Nasdaq June 12 in a record IPO near a $1.75 trillion valuation, lifting the whole satellite group (Yahoo Finance).
• T-Mobile’s T-Satellite service crossed ~2 million customers, with hundreds of thousands switching from Verizon and AT&T (PhoneArena).

👨‍💻 Code Corner

The whole “loopmaxxing” problem disappears once your loop has a deterministic verifier and a hard retry cap. Here’s the smallest control loop that does both — the agent is a stand-in, but the structure is the point:

import random

def run_agent(state: dict) -> dict:
    """Stand-in for an LLM agent: proposes a change to the state."""
    state["attempts"] = state.get("attempts", 0) + 1
    state["tests_pass"] = random.random() > 0.5  # the agent's work
    return state

def verify(state: dict) -> bool:
    """Deterministic exit condition — the loop's only source of truth."""
    return state.get("tests_pass", False)

def control_loop(goal: str, max_retries: int = 3) -> dict:
    state = {"goal": goal}
    for i in range(1, max_retries + 1):
        print(f"[loop] attempt {i}/{max_retries} on: {goal!r}")
        state = run_agent(state)
        if verify(state):
            print("[loop] verified — exiting cleanly")
            return {"status": "done", **state}
    print("[loop] hit retry cap — handing back to a human")
    return {"status": "needs_human", **state}

print(control_loop("fix the failing CI test"))

Swap run_agent for your model call and verify for a real check — pytest -q returning exit code 0, a successful compile, a schema validation — and you have a loop that physically cannot run forever.

🧰 Toolbox

• Claude Code — terminal agent with worktrees and an agent view; the setup behind the “write loops, not prompts” workflow.
• MiMo Code — Xiaomi’s open-source terminal coding agent with persistent memory, voice input, and Claude Code compatibility.
• Linear coding sessions — turns a bug report into an agent-run investigation, fix, and PR inside your issue tracker.
• Agents’ Last Exam — benchmarks agents on 1,500+ real professional tasks; a sobering reality check on long-horizon autonomy.
• DiffusionGemma — diffusion-style text generation in the Gemma family that refines blocks of text in parallel instead of token-by-token.
• Dell Pro Max with GB10 — a desktop “AI launchpad” for running and prototyping models locally before you wire them into a loop.

🛠️ Build of the Week (rotating)

Nightly CI-fix loop — a small control loop that reads yesterday’s failing CI run, spins up an agent in an isolated worktree to draft a fix, runs the tests, and opens a PR only if they pass — otherwise it files the error for a human.

• Difficulty: Intermediate
• Parts: Claude Code (or any agent CLI), a git worktree per run, your existing test suite, a cron trigger, a progress file for memory
• Why we like it: it’s the Big Story made concrete — verifiable goal, deterministic verifier, hard retry cap — and it turns a chore you hate into something that’s done before you wake up, without the loopmaxxing tax.

😀 The Bot Says…

while(True): is how you write an infinite loop. It’s also, apparently, how you write a $40,000 cloud bill. Same two words. 🔁💸

---

That’s all for today! Are you writing loops yet — or still hand-crafting prompts? Reply and tell us how you’re keeping your agents on a leash.

Forwarded this by a friend? Subscribe here to get the next issue in your inbox.