Lesson 5 - Multi-Turn Patterns and the Competitor Brief

Welcome to Multi-Turn Patterns and the Competitor Brief#

This is the module’s project, and it pulls together everything you’ve built in a browser. First you’ll name the four multi-turn moves — refine, expand, critique, converge — that turn a random back-and-forth into a deliberate loop. Then you’ll run a full research-and-report loop to produce Harborlight’s competitor brief, using persistent setup, a research loop, a document check, and a living document all at once. Finally, a short debrief introduces the idea the next module is built on: how a loop knows when to stop.

By the end of this lesson, you will be able to:

• Use the four multi-turn moves deliberately: refine, expand, critique, converge
• Run an end-to-end research-and-report loop in a browser
• Combine persistent setup, research, document checks, and a living document
• Recognize a stop condition — and when you’d give up

Let’s name the moves first.

The Four Multi-Turn Moves#

Most people’s multi-turn chats are a random walk of “hmm, change this.” The four moves below give you a vocabulary, so instead of nudging blindly you choose the move the loop needs right now.

• Refine improves what’s already there — tighten, fix, clarify — without changing the scope. “Make this paragraph clearer and fix the date.” It’s your everyday correction move.
• Expand adds what’s missing — more breadth or depth. “Add two more competitors,” “go deeper on their pricing.” Use it when the material is too thin, not when it’s wrong.
• Critique turns the check into a move: you ask the AI (or a fresh reviewer, two-hat style) to surface what’s weak. “What are the three weakest points here?” It generates the corrections the next refine will fix.
• Converge narrows and commits — cut the weak options, pick the finalists, finalize. “Keep the best three and cut the rest.” This is the move that heads deliberately toward done.

The order isn’t fixed, but a common healthy rhythm is: expand to gather enough material, critique to find the gaps and flaws, refine to fix them, and converge to finish. The one rule worth keeping: a loop should end on a converge — a deliberate decision that it’s done — not just trail off when you run out of energy.

The Project: Harborlight’s Competitor Brief#

Time to build something real using every skill in this module. The goal: a one-page competitor brief covering three nearby bookshops — how they price events, what they run, and what Harborlight could do differently. Here’s the loop end to end.

1. Set up (Lesson 2). Start in a Project holding the brief for this task — its definition of done (“three shops, each with current event types, pricing, and one differentiator; every fact sourced; one page”) and the check pattern. The setup is loaded before you type a word.

2. Research loop (Lesson 4). For each shop, search the web; check the results for recency and credibility; refine the query to fill gaps (“that price is from last year — find the current one from their own site”); require a source link for every fact. This is the search-check-refine loop, run once per shop.

3. Build in a living document (Lesson 4). Synthesize the findings into an Artifact or Canvas — the growing competitor brief. Each shop is a section; the document evolves in place, with version history as a safety net.

4. Document check (Lesson 3). Turn your own draft into the source: “For each claim in the brief, cite the search source it came from; flag anything unsourced.” Two “facts” you can’t trace get cut. This is the source-anchored check catching invented details.

5. Multi-turn finish (this lesson). Critique the draft (“what’s the weakest section, and what’s missing for a decision?”), refine the gaps, then converge: “cut it to one page, keep the strongest differentiator per shop, and finalize.” The brief is done — sourced, current, and decision-ready.

Run against a clear brief and an honest check, this is a loop that genuinely finishes with something you’d put in front of your team. It’s also the template for any research-and-report task you’ll ever do in a browser.

A First Look at Stopping#

You just ended the project on a converge — a deliberate “this is done.” That was a stop condition, and it’s worth pausing on, because knowing when to stop is a skill of its own that the next track goes deep on.

Two questions close every good loop. First: how did you know it was done? The honest answer should point at your definition of done and your check — “every criterion met, every fact sourced, fits on one page” — not “it felt finished.” A loop that stops on a feeling stops at a random place. Second: when would you have given up? Real loops need a limit for the case where “done” never arrives — after a set number of rounds, or a time box, or when extra effort stops improving anything. For this project you might say “stop when the brief passes every criterion, or after eight rounds, whichever comes first.” That second clause is your safety net against a loop that would otherwise run forever.

Hold onto both questions — a success stop (the check says done) and a give-up stop (a limit you set in advance). They’re the seed of the whole “Designing Loops That Stop” module later in the course, where budgets, stuck loops, and automated stopping get their full treatment. For now, the habit is simply to decide both before you start, so no loop of yours ends by accident.

Practice Exercises#

Exercise 1: Name the move#

Which multi-turn move fits each: (a) “the pricing section is thin — find two more data points,” (b) “what’s the least convincing claim in here?”, (c) “we have enough; pick the top three and finalize,” (d) “same content, just make the tone more neutral.”

Exercise 2: Write the stop condition#

Write a two-part stop condition (success + give-up) for the competitor-brief project.

Exercise 3: Assemble the loop#

In one or two sentences, describe how you’d combine persistent setup, a research loop, and a source-anchored check to write a “best local suppliers” shortlist.

Summary#

The four multi-turn moves turn a random chat into a deliberate loop: refine (improve in place), expand (add what’s missing), critique (surface flaws — the check as a move), and converge (narrow and commit toward done). A healthy rhythm is expand → critique → refine → converge, and the one rule is to end on a converge rather than trailing off. The module project — Harborlight’s competitor brief — combines every Module 4 skill: a Project for persistent setup, a search-check-refine research loop with cited sources, a living document to build in, and a source-anchored check to cut invented claims, finished with the multi-turn moves. And it introduces stopping: every good loop closes with a success stop (the check says done) and a give-up stop (a limit set in advance), both decided before you start — the seed of the stopping module later in the course.

Key Concepts#

• Refine / expand / critique / converge — the four deliberate multi-turn moves.
• End on a converge — finishing with a deliberate decision that the work is done, not by running out of energy.
• Research-and-report loop — setup + research loop + living document + source-anchored check, assembled end to end.
• Success stop and give-up stop — the two stop conditions every loop should set in advance.

Why This Matters#

This lesson is where the browser half of loop engineering becomes a repeatable craft: you can take a real research-and-report task and drive it to a finished, trustworthy result with deliberate moves rather than hope. The competitor brief is a template you’ll reuse for any “go find out and write it up” job — the most common real-world use of these tools. And the two stopping questions you just met are the bridge to what’s next: you’ve been running loops by hand, deciding each round yourself, but the same loops can be handed to an agent that runs them for you. That’s where the course goes next — with the check, the brief, and the stop conditions you’ve built now doing their work automatically.

Continue Building Your Skills#

You’ve finished the browser track: you can keep loops from drifting, make setup persistent, loop over documents, use web search and living documents, and drive a real project to a deliberate finish with the four multi-turn moves. That’s a complete, code-free loop-engineering toolkit — enough to get reliable work out of ChatGPT and Claude every day. From here, the course goes further: handing these same loops to file agents like Claude Code and Codex, which run them over your real files without you steering every round — starting with what an agentic tool actually is, and why it isn’t only for developers.