Build an AI Agent Without Code: A Manager's Guide to Loops
From zero to a meeting-prep assistant that runs itself — the one mental model, the prompts to paste, how to wire it to your calendar, and how it breaks. No coding.
Imagine having a chief of staff — someone whose whole job is keeping you ready for every meeting, who’s on call whenever you need it and shifts focus as the day demands: background now, your calendar next, a briefing before you walk in. You can build one yourself now, out of two features — /goal and a schedule. No code, about ten minutes of setup. One note though: the goal skill works in Claude Code only, but you can reuse the approach for Cowork or general chat.
None of this is hypothetical — it’s already how the people who build these tools work. Boris Cherny, who created Claude Code, told an audience “my job is to write loops” — and now lets Claude run “for days at a time”, some days “thousands, or tens of thousands” of agents at once. Peter Steinberger put it bluntly — “you shouldn’t be prompting coding agents anymore… you should be designing loops that prompt your agents” — and racked up millions of views; Addy Osmani named the practice: loop engineering.
The buzzwords ride one real change: the models got good enough. A year ago they couldn’t reliably check their own work, fumbled multi-step tool use, and lost the thread after a few turns — so you watched every step. This generation can judge its own output, use tools without tripping, hold the goal and the last attempt in mind at once, and retry so cheaply that ten tries don’t cost ten times as much. That’s what turns a prompt you babysit into a loop you can walk away from.
You can keep doing the prep by hand, week after week — and let the strategic work keep sliding. Or you hand the boring half to a loop and spend your attention on the judgment calls.
In this issue
What a loop actually is — the 60-second model
What goes in a goal — task · done-when · guardrails (and the one piece that stays out)
Build it in 5 steps — done-when → goal → connect → watch → schedule (~10 min)
The cheat sheet — best practices + the 5 ways it breaks, and the fix for each
The same loop in Cowork — if you’d rather skip the Terminal
5 things if you skip
1. What a no-code agentic loop is
A prompt is a one-shot instruction: you tell the model what to do, it does it once, and it stops. An agentic loop is a standing goal: you tell it what done looks like, hand it the tools, and it works toward that — acting, checking its own output, trying again — until the work clears the bar (or it hits the stop you set). Vaibhav Srivastav introduced 5 pieces of it:
It’s the same as delegation: when you need someone — say, a junior — to do a job, you tell them what to do and what success looks like.
Or in chat with any AI: you set a task, read the result and judge it, and decide whether to go again (“continue… yes… not like that,” until you start to wonder who’s automating whom).
2. What goes in a loop
Addy Osmani elaborated and added state:
Before you build — a loop is only worth it when the task repeats, you can check "done" at a glance, and a wrong run costs you nothing. Meeting prep passes all three: it happens daily, the brief is easy to eyeball, and a bad draft just gets ignored. If your task misses any of the three, keep it manual.
A loop also only earns its keep when three tests pass — it repeats often, “done” is checkable, and a wrong attempt is cheap. Meeting prep passes all three. If your task fails any, build a workflow or keep it manual.
3. Build your meeting-prep assistant in 5 steps
The build is just writing those three things into one goal, putting it on a schedule, and watching the first runs before you trust it. Each step ends with what you now have.
Step 1 — Write the done-when
This is the single most important sentence in the build — the standard the loop checks itself against. Fill in one line:
Done when ____________________________________
(the one checkable condition that means: ship it)
A wish (fails): “Done when I’m ready for my meetings.” — nothing to test, so the loop never truly stops.
A standard (works): “Done when every meeting tomorrow with two or more people (or an outside guest) has a one-page brief — who’ll be there, what it’s really about, the likely decisions, and what I should say — and any meeting too thin to brief is flagged, not faked.”
The test: could a stranger pass or fail the output against your line without asking you a single question? If not, it’s still a wish. (This is literal: /goal judges “done” from what the loop actually produced, not from what it claims — so “done” has to be something the output can show.)
Step 2 — Write the goal
Here’s a template based on 2026 best practices that you can copy-paste or adjust based on your own experience.
The task — ________________________________________________
(one line: what you want done — lead with it)
Use — ________________________________________________
(the real sources to read — calendar, the actual threads, the doc — and "don't guess")
Done when — ________________________________________________
(the checkable bar from Step 1 — what every output must contain)
Never — ________________________________________________
(read-only? don't send or change anything? stop if it's circling?)
Show me — ________________________________________________
(the shape you want back — one page each? a summary line?)
Fill it in for meeting prep, and watch your Step 1 done-when drop straight into the done-when row:
The task — Prepare me for tomorrow's meetings.
Use — tomorrow's calendar, plus our last email and Slack threads and the most recent shared doc — not guessing.
Done when — every meeting tomorrow with two or more people (or an outside guest) has a
one-page brief — who'll be there, what it's really about, the likely decisions,
and what I should say — and any meeting too thin to brief is flagged, not faked.
↑ your Step 1 done-when, dropped in here
Never — send, reply to, or change anything (read-only); and stop if it's going in circles.
Show me — one page per meeting, then one line on the day — how many prepped, how many not.Add /goal at the beginning to fire the skill.
/goal Prepare me for tomorrow's meetings.
Use tomorrow's calendar, plus our last email and Slack threads and the most recent shared
doc — not guessing. Done when every meeting tomorrow with two or more people (or an outside
guest) has a one-page brief — who'll be there, what it's really about, the likely decisions,
and what I should say — and any meeting too thin to brief is flagged, not faked. Never send,
reply to, or change anything (read-only); and stop if it's going in circles. Show me one page
per meeting, then one line on the day — how many prepped, how many not.Step 3 — Connect the data
The simplest way to set up a connector is the desktop app.
A loop can only act on what it can see, so wire it to your real tools. In Cowork, open the Customize sidebar and add the connectors your loop needs — Google Calendar and Gmail, plus Slack if you’re on a paid plan. You authorize each once with a normal Google or Slack sign-in; after that, every task can read them, and it’s the same connector system across Claude’s web and desktop apps, so you set it up once.
On your data, because you’ll be pointing this at your real inbox: connecting grants Claude access to that account under your existing permissions, and whether its actions there need your approval is a setting your org controls — so if this is a work account, check with whoever administers it before you connect. And on a personal plan, don’t assume your data is walled off from retention or training; if it’s sensitive or regulated, use your company’s enterprise Claude (with its data terms) and clear it with compliance first.
Step 4 — Run it once, watch, and verify
Don’t walk away yet — on the early runs, you are the check. Run it manually first, with “Ask permission”, and watch the whole cycle: does every meeting get a brief? Did it flag the thin ones instead of inventing an agenda? Did it ask before touching anything? Grade the outcome, not the words — open the real briefs against your real calendar, because a loop left to judge itself will happily report it’s all set — with a meeting missing or an agenda it invented. Watch it finish cleanly three times before you let it run unwatched.
You can see whether Claude set a goal.
In Terminal:
Or in the app:
Only when you’re satisfied, enable bypass permissions, as Cherny recommended — it’s the only way to let it run unattended.
My output in Terminal:
Step 5 — Schedule
When it’s performed one run successfully — meaning you’re satisfied with the result — type /schedule and answer Claude’s questions
And it’s done
4. The cheat sheet
Best practices (once it’s running)
The habits that separate a loop that helps from one that quietly burns time and tokens:
Keep state in files, not the chat. The model forgets between runs; anchor each run to a short written goal doc so a crashed loop restarts where it stopped.
Connect it to real tools so it acts — reads the calendar, opens the thread, writes the brief where you’ll see it — not a report you re-assemble by hand.
A human in front of anything irreversible. Sends, deletes, payments, anything that messages other people → keep it behind your yes. (The prompts here are read-only by design for exactly this reason.)
Encode your specifics — “my 1:1s never need a brief,” “always pull the last thread with this client” — not generic advice the model already knows.
Don’t outrun your understanding. The faster it ships work you didn’t read, the wider the gap between what exists and what you can explain. “Done” is a claim until you’ve checked it.
When it breaks
Mostly preventable with the stop rule in your goal and a look at the first runs:
It won’t stop. With nothing bounding it, an agent can repeat a failing action indefinitely; one developer watched a loop ask itself the same question 1,966 times. Another, mid-runaway, printed “I’m trapped in a loop. I know it. I’m sorry.” — it knew, and still couldn’t stop. Fix: an enforced cap (Claude Code only). A loop can’t stop itself.
It burns through your usage. Every wasted cycle still spends tokens against your plan; a loop stuck circling can eat a day’s allowance before lunch — and on a metered developer account it shows up as money (one woke to a bill that jumped $80 → $400 overnight). Fix: glance at Settings → Usage in the first days; the hard dollar cap (
--max-budget-usd) lives in Claude Code.It drifts — or fabricates. Wanders off task, or invents an agenda for a meeting it knows nothing about. Fix: a tight done-when, checking the briefs against your calendar, and “flag, don’t invent.”
It can’t reliably grade itself. The judge is the same model that did the work, so its “all done” is just another guess — it’ll call a brief complete with a meeting missing, or two things consistent when they aren’t, and sound certain either way. The self-check fails right when you’d want it to catch something. Fix: never let “done” be self-certified on anything that matters — eyeball the real output yourself on the first runs, and keep the done-when concrete enough that a wrong “done” shows at a glance.
It stops without telling you. The quiet one — I built an overnight loop that ran for months, hit an error, and just went silent. Fix: tell it to escalate when blocked instead of failing silently — and check on it.
5. Use the same approach in Cowork
You take the same prompt and replace /goal with ‘your goal is…’, connect all the same tools, and give the same permissions. Set it on a schedule and let it run.
Your goal is to prepare me for tomorrow's meetings.
Use tomorrow's calendar, plus our last email and Slack threads and the most recent shared
doc — not guessing. Done when every meeting tomorrow with two or more people (or an outside
guest) has a one-page brief — who'll be there, what it's really about, the likely decisions,
and what I should say — and any meeting too thin to brief is flagged, not faked. Never send,
reply to, or change anything (read-only); and stop if it's going in circles. Show me one page
per meeting, then one line on the day — how many prepped, how many not.
6. If you only remember five things
Build a loop only when you can’t script the steps. If step three depends on what step two turns up, you need a loop; if you can write the steps down in advance, it’s a workflow, and a workflow is simpler. Then check that it’s worth it: the task repeats, “done” is checkable, and a wrong try costs you almost nothing.
The “done-when” is the whole build. Write one sentence a stranger could grade pass or fail without asking you a single question. A wish runs forever; a standard knows when to stop.
The goal carries four things, and the schedule is separate. Pack in the task, what to read, and the done-when, then add a “never” so it stays inside the lines and a “show me” so the brief comes back in the shape you want. Set when it runs on its own, after.
On the early runs, you are the check. Grade the actual brief against your actual calendar — not the model’s cheerful report that it finished. Watch it land cleanly about three times before you hand it the keys.
Bound it or it bites. Give it a stop rule, keep it read-only on anything you can’t undo, and put yourself in front of every send, delete, and payment. A loop won’t stop itself, so you draw the line.
And that’s it! Take any repetitive task and hand it off to your assistant — the way a CEO does — and go do something fun instead.
Cheers, Alena
Thank you to all of my 11k subscribers here and on LinkedIn and huge thanks to my founding members — Kostas Nasis, Artem Krivonos, and Kristina Hananeina. Your early support made this newsletter real.