The five workflow patterns

Five shapes, one rule: in every pattern below, your code fixes the path and the model fills in the steps. That is Anthropic's definition of a workflow - "LLMs and tools orchestrated through predefined code paths" - and the exact opposite of b2's loop, where the model chose its own next move. Learn the shapes first; the code in Part 2 will read itself.

All three builds share one helper - a single plain call, no tools, no loop:

import anthropic

client = anthropic.Anthropic()

def ask(prompt: str) -> str:
    response = client.messages.create(
        model="claude-opus-5", max_tokens=1024,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.content[0].text

1 · Prompt chaining - the monthly report as three sequential calls, each output piped into the next. The tool functions are b2's Daybreak toolbox:

def chain_monthly_report(month: str) -> str:
    facts = (query_sales(month) + "\n" + top_products()
             + "\n" + subscription_status())
    numbers = ask("Summarize these raw Daybreak numbers as bullet points, "
                  "refunds excluded from revenue:\n" + facts)
    draft = ask(f"Write the {month} ops report for the founder "
                f"from these numbers ONLY:\n{numbers}")
    return ask("Polish this report: short, concrete, exactly one "
               "action item for next month.\n" + draft)

2 · Routing - one classifier call, then a plain dict dispatch. The model labels; your code branches:

HANDLERS = {"refund": handle_refund,
            "subscription": handle_subscription,
            "general": handle_general}

def route_ticket(ticket: str) -> str:
    label = ask(
        "Classify this Daybreak support ticket. Reply with exactly one "
        "word - refund, subscription, or general:\n" + ticket
    ).strip().lower()
    handler = HANDLERS.get(label, handle_general)   # safe fallback
    return handler(ticket)

3 · Parallelization - six independent month lookups have no business waiting for each other. Fan out with asyncio, then one merge call:

import asyncio

async def h1_summary() -> str:
    months = [f"2026-0{m}" for m in range(1, 7)]     # Jan..Jun
    results = await asyncio.gather(
        *(fetch_sales(month) for month in months)    # async ask() per month
    )
    return await ask_async("Summarize H1 2026 for the founder "
                           "from these six month reports:\n"
                           + "\n".join(results))

The founder asks: "Why did March revenue dip?" Below, the Daybreak agent runs the diagnosis with tools, memory, and planning on. Watch the plan step closely - the model decomposes the question into sub-investigations (sales by month, refunds, subscription changes) before touching a tool. That is orchestrator-thinking, live. The answer it assembles: February $271 → March $150, one refund (order 1017), and Liam Ford's Midnight Espresso subscription cancelled 2026-03-10.

• Build the routing workflow and run it on five sample tickets you write yourself (two refund, two subscription, one that fits nothing - watch the fallback catch it).
• Convert the monthly report chain into ONE orchestrator prompt ("plan the report, then write it") and compare the two outputs side by side: accuracy of numbers, structure, refund handling.
• Write down where the fixed path beat the agent-ish version - it should, on this task: same three steps every month is exactly what "predefined code path" is for. Bring your notes to b5, where planning makes the comparison interesting.

Certificates, videos, and graded assessments stay on the official sites (linked each session). This page covers: