From Prompts to Loops: What AI Agent Design Means for Designers Who Are Starting to Build

You've gotten comfortable prompting AI tools. You type something in, get something back, tweak it, repeat. That rhythm feels natural — almost like a conversation. But a quiet shift is happening in the world of AI-assisted building, and it's worth paying attention to even if you never plan to write a line of code yourself.

The shift is this: prompts are becoming loops.

A recent episode of Lenny's Newsletter (hosted by Claire Vo, the product leader and builder behind ChatPRD) breaks this down in plain language — and it's one of the clearest explanations we've seen of where AI tools like Claude Code and Codex are heading. Here's our take on what it means for you.

---

What Is a Loop, Exactly?

Don't let the word intimidate you. According to the episode, a loop is just an automated prompt — one that runs on its own, on a schedule or in response to an event, instead of waiting for you to hit "send" every time.

That's it. You're not learning a new paradigm. You're learning to let the prompt go do its thing without you babysitting it.

Think of it like setting an alarm versus remembering to wake up yourself. Same outcome, less manual effort.

---

The Four Types of Loops (And When Each One Fits)

The episode outlines four flavors of loops, and understanding them helps you decide which one matches the thing you're trying to automate:

1. Heartbeat — runs constantly at a steady rhythm, like a pulse. Good for monitoring something in real time.
2. Cron — runs on a fixed schedule (e.g., every morning at 10:15 a.m.). Great for recurring tasks you'd otherwise do manually.
3. Hook — fires in response to an event, like when something changes or a new file appears. Think of it as "if this, then that" — reactive rather than scheduled.
4. Goal — the most ambitious type. The AI keeps running until it achieves a specific outcome, checking its own work along the way. Also, per the episode, the hardest to write well — and the easiest to burn through AI credits on if you're not careful.

As a designer-builder, you'll probably start with cron loops (scheduled, predictable) and work your way toward goal-based ones as you get more confident.

---

The "Onboarding an Employee" Mental Model

Here's the framework from the episode that we think will stick with you: design your loop the way you'd onboard a new hire.

You wouldn't hand a new employee a vague task and walk away. You'd tell them what tools they have access to, what "done" looks like, how to flag a problem, and who to escalate to. A well-designed loop needs the same things.

The episode identifies five ingredients every effective loop needs:

• Work trees — the structure of tasks it needs to complete (think: a checklist with branches)
• Skills — what the AI actually knows how to do in this context
• Plugins/connectors — the outside tools it can reach (Slack, GitHub, a spreadsheet, etc.)
• Subagents — mini AI helpers it can spin up to handle specific subtasks (more on this below)
• State tracking — a memory of what's been done so it doesn't repeat itself or lose its place

If you're missing any of these, the loop will either stall, do weird things, or rack up costs without delivering results — two warning signs the episode specifically calls out.

---

Subagents: Your AI's AI

This is the part that feels like science fiction but is already real. In the live builds demonstrated in the episode, a single loop spawns its own subagents — smaller AI workers it delegates specific jobs to, then waits for them to report back.

In one example, a daily loop reviews aging pull requests (think: code changes that haven't been approved yet) in Claude Code. It schedules itself at 10:15 a.m. and fans out subagents to look at individual PRs before alerting the team. In another, a weekly loop in Codex identifies skill gaps and spins off subagents to validate its own output in real time.

For you as a designer-builder, this matters because it means your automation doesn't have to be one thing doing everything sequentially. It can delegate — just like a small team would.

---

Why Designers Should Care Right Now

You might be thinking: this sounds like engineer territory. It's moving faster than that.

Tools like Claude Code and Codex are already letting non-engineers set up these kinds of automated routines through conversational interfaces — meaning your ability to think clearly about what a loop should do, what its goal is, and what "done" looks like is actually the hard part. The technical scaffolding is increasingly handled by the tool itself.

That's a design problem. What does the user (your future self, or your team) actually need? When should this run? What should it check? What should it never do? These are questions designers are trained to ask.

The episode also flags two early warning signs that a loop is going to get expensive before it gets useful: vague goals and missing connectors. Both of those are, at their core, design failures — not engineering ones.

---

Where to Start

You don't need to build a subagent system this week. But here's a low-pressure on-ramp:

• Watch or listen to the full episode (linked below) — the live build walkthroughs are especially useful for seeing how this works in practice.
• Pick one thing you do manually on a schedule — a weekly check-in, a daily status update, a recurring review — and ask yourself: if I were onboarding an AI to do this, what would I tell it?
• Sketch the loop like you'd sketch a user flow: trigger → task → output → check. That's the design spec.

The tools are catching up to this way of thinking fast. The designers who start thinking in loops now — even just conceptually — will have a real head start when the interfaces make it trivially easy to build them.

Loops aren't the future. They're the present. Let's get curious about them.