Guided workshop

Ship Day:
The Build Loop

How to collaborate with your AI agent while something is being built

“Today isn’t about finding the perfect prompt. It’s about learning how to work with your agent while something is being built.”

The focus

The focus is not learning how to code.

The focus is learning how to direct, review, react to, and improve what your agent is building.

Begin the workshop

Core promise

By the end of the workshop, everyone will have:

  • A small working project or prototype
  • Experience collaborating with their agent in stages
  • A chance to review and redirect the build
  • A real test result
  • A clear decision about whether to ship, revise, share, or pause

The focus is not learning how to code.

The focus is learning how to direct, review, react to, and improve what your agent is building.

Part One: Set the context

1. Welcome and reframe: 5 minutes

Open with:

“Today isn’t about finding the perfect prompt. It’s about learning how to work with your agent while something is being built.”

Then explain how this differs from the previous training:

  • Last time: moving from an idea to a first asset
  • Today: learning the collaboration rhythm that makes building with AI actually work
  • The focus is not ideation, planning, or automation design
  • The focus is staying in the loop

You could also say:

“Your agent is not a vending machine where you enter a prompt and hope the right thing comes out. It’s more like a fast junior builder who needs direction, feedback, and testing.”

The point isn’t that the agent is incapable. The point is that a good result comes from collaboration, not one giant request.

Set the workshop expectation:

“I’m not going to build something while you watch. We’re going to move through the process together. I’ll explain each step, you’ll use that step with your own agent, and then we’ll come back together before moving on.”

2. The problem with the giant prompt: 10 minutes

Show the common approach:

Build me a complete website for my business with a homepage, about page, services, contact form, blog, testimonials, animations, mobile responsiveness, SEO, and a beautiful brand design.

Talk through why this often goes wrong:

  • The agent has to guess too many things
  • The scope is too large to review easily
  • Important decisions get buried
  • Revisions become confusing
  • The agent may spend time polishing the wrong direction
  • The person doesn’t know where to intervene
  • It becomes difficult to tell whether the project is actually working

Then introduce the alternative:

“Give the agent enough direction to take the next useful step, not enough instruction to disappear for an hour.”

Explain that the goal is not to give the agent less information. The goal is to give it the right information at the right stage.

Part Two: Learn the full Build Loop

3. Introduce the Build Loop: 10 minutes

Show the complete process before participants begin:

Direct → Build → Review → React → Revise → Test → Ship
  1. Direct
  2. Build
  3. Review
  4. React
  5. Revise
  6. Test
  7. Ship

Explain that this is a loop, not a straight line. You may move through it more than once.

Direct

Give the agent the context, purpose, audience, constraints, and immediate next step.

Build

Ask the agent to create one small, visible piece.

Review

Look at what actually exists instead of assuming it matches what you meant.

React

Describe what feels unclear, incorrect, missing, unnecessary, or off-brand.

Revise

Ask for a focused change while protecting what is already working.

Test

Use the project as a real user and see what happens.

Ship

Make a decision: use it, share it privately, revise it once, or pause because of a real blocker.

Then explain:

“We’re going to walk through this loop together. I’ll teach one step, you’ll apply that step, and then we’ll regroup before moving on.”

Part Three: Guided workshop

01

4. Step One: Direct

Teach

The first direction should give the agent enough context to take the next useful step.

It should clarify:

  • Who the project is for
  • What problem it solves
  • What the user should be able to do
  • What version one should avoid
  • What the agent should do first

The goal is not to explain the entire future project. It is to create a strong starting point.

Build activity

Participants choose a small project to work on.

They can build:

  • A decision tool
  • A quiz or self-assessment
  • A simple calculator
  • A guided checklist
  • A small resource or microsite
  • A tiny content or idea generator

Give them this starting prompt:

Exact participant prompt
I want to build a small tool for [specific user].

The problem it should help with is [specific problem].

The user should be able to [one clear outcome].

For the first version, I want to keep this small and focused.

Before building anything, ask me the most important questions you need answered.
Regroup

Ask participants:

  • What questions did your agent ask?
  • Did it reveal anything you hadn’t decided yet?
  • Did you accidentally make the project too large?
  • Can you explain what you’re building in one sentence?

Part Three: Guided workshop

02

5. Step Two: Build

Teach

Once the agent understands the direction, don’t ask for the entire finished project.

Ask it to build one small, visible piece.

This might be:

  • The opening section
  • The first screen
  • The first question
  • The basic calculator logic
  • The initial page structure
  • The first result state
“We want something we can review quickly. If the direction is wrong, we want to find that out before building five more layers on top of it.”
Build activity

Participants ask their agent to propose the smallest useful version:

Exact participant prompt
Based on what we’ve decided, propose the smallest useful version.

Show me:
- The core user
- The main action
- The inputs
- The output
- The basic steps or screens
- What is intentionally out of scope

Do not build the full project yet.

Then they choose one piece:

Exact participant prompt
Build only [specific section, screen, or function].

Do not add extra features or polish yet.

After building, tell me:
- What changed
- What assumptions you made
- What I should test
Regroup

Ask:

  • What did the agent build?
  • What assumptions did it make?
  • What surprised you?
  • Is this still the project you meant to make?

Normalize that the first build may not be right yet. That is the purpose of reviewing early.

Part Three: Guided workshop

03

6. Step Three: Review

Teach

Review means looking at the actual result before immediately telling the agent what to change.

Have participants review from the user’s perspective:

  • Is the purpose clear?
  • Is the next action obvious?
  • Does the tone feel right?
  • Is anything missing?
  • Is anything unnecessary?
  • Does it solve the original problem?
  • Did the agent misunderstand the user?
“Reviewing isn’t approving or rejecting. It’s noticing what is actually happening.”
Build activity

Have participants use the project without revising it yet.

Exact participant prompt
Review this as if you were the intended user.

Write down:
- What is clear
- What is confusing
- What feels unnecessary
- What is missing
- What does not match the original purpose
Regroup

Invite a few quick shares:

  • “My agent assumed…”
  • “I realized the user needs…”
  • “The part that feels off is…”
  • “The thing I thought mattered most actually doesn’t…”

Part Three: Guided workshop

04

7. Step Four: React

Teach

This is where participants give the agent useful feedback without needing to diagnose the code.

Introduce the feedback structure:

What I notice → Why it matters → What I want changed → What should stay the same
Build activity
Exact participant prompt
Here’s what I’m noticing:

[describe what feels wrong or unclear]

Here’s why it matters:

[explain the impact on the user or result]

Please change:

[name the specific section]

Keep these parts unchanged:

[list what is already working]

Example:

Exact example
The opening section feels too abstract.

The user doesn’t immediately understand what this tool will help them decide.

Rewrite the opening so the audience, problem, and expected result are clear within a few seconds.

Keep the current layout and first question unchanged.
Regroup

Ask:

  • Did you describe the problem or try to prescribe the code?
  • Did you explain why the issue matters?
  • Did you tell the agent what to preserve?
  • Did your feedback stay focused on one issue?

Part Three: Guided workshop

05

8. Step Five: Revise

Teach

Revision should be focused, not a complete restart.

“A revision is not an invitation to redesign everything. It’s a chance to make the one change that improves the result most.”
Build activity
Exact participant prompt
Make the focused revision we discussed.

Do not redesign or rebuild unrelated parts.

Afterward, summarize:
- What you changed
- What stayed the same
- Any new assumptions
- What I should review next

Participants review the updated version.

Regroup

Ask:

  • Did the revision solve the actual problem?
  • Did it change anything that was already working?
  • Did the agent add anything you didn’t ask for?
  • Is another revision truly needed, or are you just tempted to keep improving it?

For the workshop, introduce a one-revision rule. Everyone gets one focused improvement before testing.

Part Three: Guided workshop

06

9. Step Six: Test

Teach

Testing means using a realistic example and seeing what happens.

It is not waiting until the end to discover that the project doesn’t work.

Participants should test:

  • The intended user flow
  • The clarity of the instructions
  • The output or result
  • Anything they were worried the agent misunderstood
  • Whether the tool solves the original problem
Build activity
Exact participant prompt
Test this with the following realistic example:

[user scenario]

Walk through the experience and tell me:
- What works
- What is confusing
- What breaks
- Whether the result solves the original problem
- The one highest-value improvement, if there is one

Participants then use the project themselves and compare the result with their original intention.

Regroup

Ask:

  • Did the project work from beginning to end?
  • Did the result feel useful?
  • Did the test reveal a real issue?
  • Is it important enough to fix today?
  • Is it a blocker or simply a future enhancement?

Part Three: Guided workshop

07

10. Step Seven: Ship

Teach

Shipping does not necessarily mean launching publicly.

For this workshop, shipping means the idea has become a working version that can be used, shared privately, or evaluated honestly.

Give participants four possible decisions:

Ship

The tool works well enough for its intended low-risk use.

Share privately

The tool is useful, but they want feedback before public use.

Revise later

There is one clear improvement, but it does not prevent the current version from being useful.

Pause

A real missing decision, asset, or technical issue prevents responsible completion.

“Do not keep building simply because more building is possible.”
Build activity
Exact participant prompt
Evaluate this version against the original purpose.

Tell me whether it is:
- Ready to use
- Ready to share privately
- Worth one focused revision
- Blocked by a real issue

Explain the decision briefly.

Do not suggest a feature backlog. Recommend only the next most useful action.

Each participant chooses their own shipping status.

No shipping status selected.

Part Four: Closing and share

11. Participant share: 10 minutes

Have everyone share:

  • What they built
  • Where their agent misunderstood them
  • What changed after review and testing
  • Whether they shipped, shared privately, revised, or paused

The key reflection question:

“What did you learn about how to work with your agent that you can use on your next build?”

You could also ask:

“Which part of the Build Loop do you usually skip?”

That helps them identify their personal pattern.

12. The challenge

“Before our next training, use the Build Loop on one small thing you actually need. Don’t ask your agent to build the whole project at once. Direct it, review early, give focused feedback, test it, and make a clear shipping decision.”

Their challenge is not to build something bigger.

It is to repeat the collaboration rhythm.

Final positioning

Stay the owner of the result.

“Today isn’t about learning how to make AI code for you. It’s about learning how to direct, review, test, and improve what your AI is building so you stay the owner of the result.”

The workshop rhythm is:

Teach the step → participants apply the step → regroup → teach the next step

That gives them the full map first, but they experience every part of the map themselves instead of watching you complete a separate demo.