A Weekend Gonzo Field Guide to /loop Engineering

Another weekend piece of satire, devoid of real-life advice but stacked with enough cyberpop residue to pass as insight. Grab your chai tea and add another scoop of ashwagandha, and hang on.

The Mafia Boss Was Right

I watched Looper the other week for the 8th time. Bruce Willis and Joseph Gordon-Levitt—I had to look him up to remember his name as well, the Inception guy. He was good in the film, not quite Bruce Willis tier yet, but the hover bike scene was epic, and you know you want one. The movie is about time loops, obviously, but the line I can’t shake is the mob boss who says “go to China, kid, that’s where everything is happening.”

He wasn’t wrong. Very prescient indeed; also, he did have access to a time machine, so that is easy to say in retrospect.

Chinese cities have hit Blade Runner rendering at 4K, from a distance that most Western cities won’t reach for another decade. AI-controlled infrastructure, EVs from wall to wall, drone delivery to your apartment, and facial/palm recognition at the checkouts. Then you scroll back to most Western cities, and it’s underwhelmingly patchy: some surveillance cameras bolted to old telephone poles if they haven't been cut down, a couple of EV charging stations in the nice part of town, clusters of fast food shops, and the crowd went mild.

The uncomfortable question isn’t technical. It’s political funding and lack of infrastructure. Can you get that level of coordinated city tech without the control structure that produced it? Can you be a selective quasi-futurist and take the drone delivery and skip the social credit score?

Hard questions to answer even for Mustapha Mond while neck-deep into a weekend soma binge.

Your perspective probably depends on where your loyalty sits and also whether you’ve ever had Amazon lose a parcel or seen your face on a digital billboard for jaywalking and not paying the auto-fine. Can't we just have a common-sense middle ground mix of the future promised and self-sovereign autonomy?

It's like when you're at the takeaway shop and you are asked if you want chicken salt or gravy on your chips/fries.

I want both the gravy and the chicken salt included. Where in the rulebook did we have to lose all of our freedoms to gain future tech conveniences?

Why would anyone accept anything less from their governments?

That aside, the real loop I want to talk about is the one about to happen in your terminal right now. Or the one that already has, if you're an uber-tech-cool dude with a mustache.

It is definitely a trend… both the /loop and the mustache.

Stop Prompting Like a Caveman

Peter Steinberger said it plainly:

“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 essentially the same thing from the inside as he chuckled at your 2025 prompting skills:

“I don’t prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops.”

The age of the perfectly crafted prompt recipe with that artisanal, hand-ground, single-origin crema you either copied from a GitHub repo or spent forty-five minutes composing is ending. Why?

Not because prompts are useless. They’re not. But treating a prompt as the unit of work is like writing every email as a manual process when you could have written one rule that handles all of the send/return emails forever.

Loop engineering is the move from user of tool to designer of system. You stop being the person who types like a caveman. You become the person who builds the thing that types, like a Gödel boss.

Kurt liked logic, and so should you: /loop it

And before you say “that sounds expensive," you're right for once; it is!

We’ll get to how to save on those bougie token costs. Not everyone has Boris’s Anthropic employee token credit line or Steinberger’s OpenAI gargantuan startup budgets.

We just need a few more billion; is that ok? Just one more, and then we will stop, just a little more GPU inference seed money. We will pay you back, I promise in the IPO.

Look at the SpaceX IPO, it hit $170 today, not bad, my wife couldn't stop talking about it: “We need SpaceX; we are going to Mars”, we are probably not going to Mars, as there is no atmosphere and there are no shops or fish and chip takeaways. It sounds boring to be honest, red dirt, besides the achievement part for humankind. I’m not interested in becoming a potato farmer like Matt Damon.

The frenzy around it, the oversubscribed rounds, the institutional queues, and the retail hysteria, tells you something important that has nothing to do with rockets. That there are billions of dollars out there actively sloshing around, desperately looking for somewhere to land.

Sovereign wealth funds, pension managers, venture firms, and retail investors are all competing for the same scarce commodity: a compelling place to put money to work. The capital exists for technology investing.

So when people argue that we lack the resources to address climate change, the unhoused in tents, crumbling infrastructure, or antibiotic resistance, they are not quite telling the truth. The resources are there. The issue is not that there is not enough capital to solve today’s problems. The issue is where it all goes.

Cron Is a Metronome. A Loop Is a Heartbeat. Know the Difference.

Cost-effective looping is a first-class concern here, and we will get down to brass tacks soon, but first I have to go on another technical tangent.

Here’s the question I kept bouncing around: What's the actual difference between cron and looping agentically?

It sounds like a silly question until you realise most people conflate them and then build the wrong thing.

Cron is time-driven, as Chronos is the master of time… You are learning today!

It says, "Run this at 2am every day." It does not care what happened before. It wakes up, fires the job, and goes back to sleep. Cron is for periodic tasks — backups, syncs, log rotation, and report generation. It assumes the world can wait for the schedule.

A loop is state-driven. It says, "Keep going until this condition is true." It reacts. It retries. It pauses. It watches. A loop assumes the world is changing while it’s running.

The practical split for agentic work:

In Claude Code terms: /schedule or GitHub Actions for cron-style cadence. /loop for "keep iterating," /goal for "keep going until this specific condition is verifiably true."

The /goal primitive is the spicy one: it runs a separate model to check whether you're actually done, so the agent that wrote the code isn't also the one grading its own homework.

That’s the maker/checker split, and it’s the single most important structural idea in loop design. We’ll come back to it, don't worry and sorry if this bored you, super coders.

The Six degrees of Kevin Bacon loop separation
A loop running unattended is not one long prompt in a while loop. It’s a small system with six parts. Five capabilities, one spine.

Part 1 — Automations: The Heartbeat

The heartbeat is what makes it a real loop and not just a one-off agent session you ran once and forgot about.

In Claude Code: /loop [interval] for recurring runs, /goal for run-until-done, hooks and GitHub Actions for persistence outside the chat session. The /goal pattern is particularly powerful: you write a verifiable stopping condition ("all tests in test/auth pass and lint is clean"), walk away, and a fresh model checks it at each turn rather than the worker checking itself.

Quick start:

Run a triage scan every morning at 8am via GitHub Actions

.github/workflows/morning-triage.yml

on:
schedule:
- cron: '0 8 * * 1-5'
jobs:
triage:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Run Claude triage loop
run: claude -p "$(cat .claude/prompts/morning-triage.md)" --output-format json > triage-output.json
Keep the heartbeat cheap. Discovery and triage should cost pennies. Sub-agents that actually do work should only spawn when the state file says there’s something worth doing.

Part 2 — Worktrees: Parallel Without the Pile-Up

Two agents writing the same file simultaneously is a merge disaster. Git worktrees fix this by giving each agent its own working directory on its own branch, sharing history but never colliding.

Spawn an isolated worktree for a parallel agent session

git worktree add ../feature-auth-fix -b fix/auth-token-expiry

Claude Code flag

claude --worktree fix/auth-token-expiry "Fix the token expiry bug in auth.ts"

In .claude/agents/verifier.md — set isolation

isolation: worktree

Each sub-agent gets a fresh checkout, auto-cleans on exit

The rule: one agent, one worktree. They can share the repo history. They cannot share the working directory.

Part 3 — Skills: Stop Explaining Your Project From Scratch Every Single Run

Every session, the agent starts cold. Your conventions, your build commands, the reason you never use that particular pattern — gone. Unless you wrote it down.

A SKILL.md file is how you externalise intent. It's the project knowledge that should survive across runs. Without it, every loop iteration is day one. With it, the loop compounds.

Structure for a useful skill file:

.claude/skills/
project-conventions.md # naming, patterns, things we don't do
testing-standards.md # what "done" means for tests
deployment-checklist.md # what the loop should verify before PR
review-criteria.md # what the verifier checks
The skill description matters more than the content. A tight, boring description beats a clever one, as the agent needs to match it reliably, not be impressed by it.

Part 4 — Connectors: From Commentator to Operator

A loop that can only see the filesystem is a loop that can only suggest. MCP-based connectors are what let it act: open PRs, update Linear tickets, post to Slack, query staging APIs.

The difference between an agent that says “here’s what I’d do” and a loop that opens the PR, links the ticket, and pings the channel when CI goes green.

Both Claude Code and most modern agent tools now speak MCP natively. A connector written for one tends to port easily to another. Priority connectors for a useful coding loop: GitHub (PRs, issues), your issue tracker (Linear, Jira), Slack or Discord for human handoff alerts.

Part 5 — Sub-Agents: The Maker/Checker Split

This is the most important structural decision in any loop you build.

The agent that wrote the code is too invested in its own work to catch its mistakes. This is not a model flaw — it’s structural. You need a second agent with different instructions, sometimes a stronger model, to verify.

.claude/agents/implementer.md

name: implementer
model: claude-haiku-4-5 # fast, cheap, does the work
instructions: |
Implement the task from STATE.md.
Write code, run tests, log results.
Do NOT approve your own work.

.claude/agents/verifier.md

name: verifier
model: claude-sonnet-4-6 # stronger model for the judgment call
instructions: |
Review the implementer's output against:

• .claude/skills/testing-standards.md
• .claude/skills/review-criteria.md Approve, reject with specific reasons, or escalate to human. The typical split: explorer (fast, broad), implementer (focused, executes), verifier (different instructions, checks against spec). Token budget: the implementer can be Haiku, the verifier earns Sonnet.

Part 6 — State: The Spine Everything Else Runs On

This is the least glamorous part and the most important.

The loop forgets everything between runs. The state file doesn’t. It’s what lets tomorrow’s run pick up where today’s stopped. Three questions a good state file always answers:

What are we working on right now?
What did we try last time, and what happened?
What needs a human?

LOOP-STATE.md

Active

• [ ] AUTH-247: Fix token expiry race condition (implementer in progress, worktree: fix/auth-token-expiry) ## Completed This Run
• [x] AUTH-231: Null check on refresh handler (merged PR #412)
• [x] LINT: Trailing whitespace in auth.ts (fixed) ## Awaiting Human
• AUTH-239: Database migration required — scope unclear, needs review
• TEST: Integration test failing on CI but not locally — environment mismatch suspected ## Last Run 2026-06-11 08:00 — Triage: 3 issues found, 2 actioned, 1 escalated Keep it in the repo. Commit it. The state file is often the most valuable artifact the loop produces.

A Real Loop in One Page

Stick the six parts together and here’s what a practical morning loop looks like:

8:00am — GitHub Actions fires morning-triage.yml
↓
Triage agent reads: CI failures, open issues tagged "bug", recent commits
→ Writes findings to LOOP-STATE.md
→ Rates each item: actionable / needs-human / skip
↓
For each actionable item:
→ Spawn implementer agent in isolated worktree
→ Implementer reads relevant SKILL.md files
→ Implementer makes changes, runs tests
→ Writes result to LOOP-STATE.md
↓
Verifier agent reads implementer output
→ Checks against review-criteria.md
→ Approve: open PR via GitHub MCP connector
→ Reject: log reason in STATE.md, flag for next run
→ Escalate: post to Slack with context
↓
Human receives: Slack summary + PR links + anything needing eyes
You designed that once. You didn’t prompt any of those steps. Those are Steinberger’s & Boris’s points made concrete.

The Token Problem Is Real and Here’s How You Don’t Go Broke
Look, not everyone has Boris’s Anthropic tab. Token costs in a naive loop can go from “productivity win” to “budget incident” very fast. Here’s how to stay cost-effective.

The tiered model pattern. Use cheap models for cheap work.

Discovery and triage: Haiku. Fast reads, structured output, costs almost nothing.
Implementation: Haiku or Sonnet depending on complexity. Let the skill file define escalation criteria.
Verification: Sonnet. This is where the judgment matters. Spend here.
State file updates: Haiku. It’s just structured writing.
Rough hierarchy: Haiku ≈ 70% cheaper than Sonnet for similar throughput tasks. Route accordingly.

The conditional spawn rule. Sub-agents should only spawn when the state file says the item is worth doing. Don’t fan out speculatively. Triage first (cheap), act second (less cheap), verify last (worth it).

The /goal brake. Always write stopping conditions. A loop without a stopping condition is a billing event.

Good: verifiable stopping condition

claude --goal "all tests in test/auth pass, lint exits 0, PR is open"

Bad: open-ended

claude --loop "keep improving the auth module"
The budget flag. Claude Code supports max turn limits. Use them.

claude --max-turns 15 --goal "fix the failing tests in test/auth"
Fifteen turns at Haiku rates is basically super cheap. Fifteen turns at Sonnet with tool calls is still reasonable. Unlimited turns with a badly specified goal is how you end up explaining a bill to someone.

Can we put the $500 million API bill on the company credit card? Is that OK? I don't want to cause any waves or anything… Bruce in engineering says he is sorry.

The Robovac Digression (Which Is Actually About Architecture)

My robovac got me thinking; honestly, it’s the perfect test case for all of this. We keep cramming intelligence into devices that have exactly one job in the physical world. Clean the floor. Don’t eat the charging cable. Go home before the battery dies, without bumping into the chair legs.

But every device hacker looks at that humble spinning disc and thinks, "What if it also had intelligence and a GPU?" What if it knew the weather, played your morning playlist, and helped you with movie trivia in the TV lounge room?

That's how you end up with a household appliance that needs its own token maxxing limits, a system prompt, a SKILL.md, and a therapy session when you rearrange the living room.

But here’s the thing — a robovac is actually a perfect minimal loop. It has all six parts already, just implemented into custom firmware:

Automation: scheduled clean at 7pm, or triggered by event (you left the house)
Worktrees: doesn’t try to clean two rooms simultaneously (collision avoidance)
Skills: map of your floor, no-go zones, the spot under the couch it learned the hard way
Connectors: dock charger, app notifications, voice assistant integration
Sub-agents: the part that navigates and the part that decides when it’s done
State: the map. The map is everything.
The architecture of a good robovac is the architecture of a good loop. One does it in 50MB of Linux firmware. The other does it in your .claude/ folder. Same bones.

The actual robovac AI opportunity, for whoever wants it: tiny local model for intent parsing (“clean the kitchen after dinner”), deterministic command layer for safety, existing firmware for motion. Don’t overthink it. The AI is not the vacuum.

The Robovac is the future existential crisis support chatbot, just like Michael Reeves early iteration of the swearing roomba:

https://www.youtube.com/watch?v=mvz3LRK263E

8. What The Loop Can’t Do For You

The loop changes the work. It doesn’t delete you from it. And three problems get sharper as the loop gets better.

Verification is still yours. A loop running unattended is also a loop making mistakes unattended. “Done” is a claim, not a proof. The verifier sub-agent helps, but it doesn’t replace you reading what landed in the repo. Your job is to ship code you confirmed works, not code the loop says works.

Comprehension debt compounds. The faster the loop ships code you didn’t write, the wider the gap between what exists and what you actually understand. A smooth loop accelerates that gap unless you stay engaged with what it’s producing. Read the PRs. Understand the changes. The loop is a multiplier on your engineering judgment, not a replacement for it.

Cognitive surrender is the comfortable failure mode. Two people can build the exact same loop and get completely opposite outcomes. One uses it to move faster on work they understand deeply. The other uses it to avoid understanding the work at all. The loop doesn’t know the difference. You do.

HITL for life: Design the loop like someone who intends to stay the engineer.

One Last Thing: Prompting Isn’t Dead, It’s just not cool anymore
The prompt is still the steering wheel. It’s just not the whole engine.

If your system already knows the codebase, remembers your conventions, and can inspect its own output, the prompt becomes a short instruction to a system that already knows what to do with it. Context engineering, skill files, agent loops, persistent state: these are what replaced the long incantation.

The tech industry is trying to sound 17% more post-uber-human than the next person. Token-maxxing. Microflex mind hacks via dubious mail-order peptide injections. “93% productivity improvement” posts with no receipts. The social flex posts will keep peacocking and evolving. The receipts matter more than the claims.

The ideas here are simple: a loop that runs while you sleep, finds real work, does it reasonably well, escalates the parts it can’t handle, and leaves a state file you can actually read in the morning.

That’s it. Not a "shut up and take my money" for a deposit on a Neuralink implant chip. Just a .claude/ folder, a few skill files, a state markdown, and a cron trigger.

All hail the /loop. Stay the engineer. And stop explaining your project from scratch to an AI that could have just looped it.

Published on @vektormemory — VEKTOR Memory is a local-first AI agent memory SDK. If your loop could use persistent memory that doesn’t phone home, check it out at vektormemory.com.

LLM
Anthropic Claude
Prompt Engineering
Claude Code