In today’s newsletter:

• Monitor Your AI Coding Agent From Anywhere

• Loop Engineering: Clearly Explained

Reading time: 5 minutes.

Monitor Your AI Coding Agent From Anywhere

AI coding agents don't need you watching them. They write code, run tests, and debug issues on their own. But every time they need approval or hit an error, you're back at your desk staring at a terminal.

The time you spend sitting in front of a screen is no longer what determines how much gets done. What matters is knowing when your agent needs you and being able to respond without stopping what you're doing.

Terminal Mode from Even Realities changes this. It streams your agent's live status directly into the Even G2 smart glasses. When it needs input, you respond with a tap or a voice command and keep moving.

How it works:

Install the Even Terminal CLI, pair it with the Even Realities app, and connect it to your agent. The glasses pick up live updates from running sessions through the Terminal Interface without you touching your laptop.

What changes:

Developers are increasingly in a supervisory role over agents rather than an execution one. Terminal Mode is an early look at what that actually feels like in practice: your agent is working, you know what it's doing, and you're not tied to a screen to stay in the loop.

#CodeInTheWild

Even Realities is running a contest around this idea. Show yourself supervising an AI agent somewhere you'd never normally be able to. Submissions run June 16 to June 19, with Codex Pro packages for the top 20 entries.

Join #CodeInTheWild →

Loop Engineering: What It Is and When to Use It

Two statements went viral in the developer community this year.

Peter Steinberger, creator of OpenClaw, posted: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."

Boris Cherny, head of Claude Code at Anthropic, said it differently: "I don't prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops."

And both left developers asking the same question: what does that actually mean?

What Changed

For the past two years, working with a coding agent meant you typed a prompt, read what came back, decided what to say next, and repeated. You were the loop. The agent was a tool you held.

Loop engineering replaces you as the person doing the prompting. You build a system that finds the task, hands it to the agent, checks the result, records what happened, and decides what comes next. The system runs the agent instead of you running the agent.

The Five Pieces a Loop Needs

A working loop has five components. Both Claude Code and Codex ship all five now.

Automations. The heartbeat of the loop. You define a prompt, a cadence, and a project. The automation runs, finds tasks, drops findings into a triage inbox, and archives runs that find nothing. Without this, you have a single run, not a loop.

Worktrees. Two agents writing the same file at the same time is the same problem as two engineers committing to the same lines without talking. A git worktree gives each agent its own isolated checkout on its own branch. Collisions disappear structurally.

Skills. A SKILL.md file that holds your project's conventions, build steps, and context. Without skills, the loop re-derives your project from zero every cycle. With skills, that knowledge loads every run without you re-explaining it.

Connectors. MCP connectors let the loop reach beyond the filesystem: read your issue tracker, open a PR, update a Linear ticket, post to Slack when CI passes. An agent that can only see the filesystem is limited. Connectors are what let the loop act inside your actual environment.

Sub-agents. The most important structural decision in any loop: split the agent that makes from the agent that checks. The model that wrote the code is too lenient grading its own work. A second agent with different instructions, ideally a different model, catches what the first one rationalized.

What It Looks Like in Practice

Here's the same task done both ways.

With prompting: Every morning, you open your agent, check CI failures manually, paste the errors, ask for a fix, review the output, run the tests, and commit if it passes. You do this for each failure. You are the loop.

With a loop: An automation runs at 7 am. It reads yesterday's CI output, identifies failures, opens an isolated worktree per failure, sends a sub-agent to draft the fix, sends a second sub-agent to verify the fix against your test suite, and opens a PR for anything that passes. You wake up to a triage inbox. Your job is reviewing what the loop already validated, not running it.

The task is the same. Your role in it is different.

The Token Cost Is Real

This is where most people underestimate the shift.

A prompt you type costs one LLM call. A loop pays that cost every iteration, and carries the full accumulated context each time. The longer it runs, the more each step costs.
Add verification sub-agents, and the spend multiplies again. Each sub-agent runs its own independent set of calls. Parallel workers, parallel bills.

This is not hypothetical. Uber burned its entire 2026 AI coding budget in four months after Claude Code adoption jumped from 32% to 84% of their 5,000 engineers.

When to Use It and When Not To

A loop pays off when four conditions are met:

• The task recurs on a schedule

• Verification can be automated

• Your token budget can absorb the overhead,

• The agent already has the tools a senior engineer would need to complete the task.

Use direct prompting for one-off tasks, well-defined work that fits in a single session, and anything where you want to stay in direct contact with what the agent is doing.

Use a loop when the work repeats, when you want multiple agents running in parallel on the same repo without collisions, or when a task is too large for one session and needs to preserve state across runs.

So Does It Replace Prompt Engineering?

Not quite. It sits one layer above it.

We moved from prompt engineering to context engineering to harness engineering, and now loop engineering. Each layer adds scope without replacing the one below. The loop still contains prompts. You still need to write them well. The difference is that those prompts run against a system you designed rather than whatever you type this morning.

What changed is the leverage point. A prompt you write lasts one session. A loop you design runs every morning, scales across agents, and compounds over time.

That’s all for today. Thank you for reading today’s edition. See you in the next issue with more AI Engineering insights.

PS: We curate this AI Engineering content for free, and your support means everything. If you find value in what you read, consider sharing it with a friend or two.

Your feedback is valuable: If there’s a topic you’re stuck on or curious about, reply to this email. We’re building this for you, and your feedback helps shape what we send.

WORK WITH US

Looking to promote your company, product, or service to 200K+ AI developers? Get in touch today by replying to this email.