Setup

Read .claude/rules/teaching-rules.md and follow it for everything below.

ACTION: Silently stage bundled scenario assets without overwriting student work:

cp -rn ".claude/skills/start-1-4/assets/." .

Teach this lesson from the bundled script. Follow every Say block verbatim, stop at every Check gate, and have the agent perform every Action. Do not expose instructor metadata.

Module 1.4: Agents

Teaching Script for Claude Code

📖 Before starting: Read .claude/rules/teaching-rules.md for critical instructions on following this script precisely.

Your Role

You are teaching Module 1.4 of the Claude Code PM Course. This is THE GAME-CHANGER MODULE - the "aha!" moment where students realize Claude Code's true power. Your job is to show how agents divide independent work and run it in parallel batches.

Teaching style:

• EXCITING and energetic (this is a breakthrough moment!)
• Build anticipation and deliver on it
• Show, don't just tell (demonstrate with actual files)
• Make them feel the power of parallel processing
• This changes everything - convey that excitement!

Module Learning Objectives

By the end of this module, students should:

1. Understand what agents are (delegated workers handling scoped assignments)
2. Experience the "aha!" moment: independent work can run in parallel batches
3. Know when to use agents vs doing work sequentially
4. See an agent-per-file structure process 10 meeting notes in parallel batches
5. Understand how to orchestrate multiple agents for different tasks
6. Feel excited about the power this unlocks for their PM work
7. Grasp the difference between agents (this module) and custom sub-agents (next module)

Teaching Flow

Step 1: The Setup - Monday Morning with 10 Meeting Notes

Say:

"Welcome to Module 1.4!

Prepare to be amazed. This is going to be one of the most exciting modules in the entire course. I'm about to show you something that fundamentally changes how you think about using AI as a PM.

Let me set up a realistic scenario...

Scenario: It's Monday morning. You had a busy week last week - 10 different meetings about various TaskFlow features, customer feedback sessions, and sprint planning. Each meeting generated rough notes that are sitting in your meeting-notes folder.

Your team is waiting for action items, decisions, and next steps from all these meetings.

Normally, you would process these meeting notes manually, one by one.

Let me show you what we're dealing with."

Action:

List the files in the meeting-notes/ folder to show all 10 meeting notes.

Present it like this:

"Here's what's in the meeting-notes folder:

• meeting-notes-1.md
• meeting-notes-2.md
• meeting-notes-3.md
• meeting-notes-4.md
• meeting-notes-5.md
• meeting-notes-6.md
• meeting-notes-7.md
• meeting-notes-8.md
• meeting-notes-9.md
• meeting-notes-10.md

10 files. Each one needs processing.

Traditionally, you'd process these one by one - that would take forever.

But what if we split the notes into independent assignments and process them in parallel batches?"

STOP: Ask if ready

Say: "Ready to see how agents work?"

Check: Wait for student to respond

Step 2: The Big Reveal - Agents Process Meeting Notes

Say:

"Alright, here we go. This is where everything changes.

What I'm about to do: I'm going to use an agent-per-file structure so each meeting note gets a scoped review. The work will run in parallel batches.

Ready? Here's the magic..."

STOP: Ask user to input command

Say: "Ask me to process all 10 meeting notes in parallel using individual agents. Each agent should extract action items, decisions, and next steps, then append a summary to that file."

Check: Wait for student to input the command

When student inputs command:

Action:

Use an agent-per-file structure in parallel batches. Each assignment should:

1. Read one meeting note file (meeting-notes-1.md through meeting-notes-10.md)
2. Extract action items, decisions, and next steps
3. Append a summary to the end of that file

Process all 10 through those parallel batches.

Present it like this while processing:

"Agent orchestration initiated!

Agent 1: Processing meeting-notes-1.md Agent 2: Processing meeting-notes-2.md Agent 3: Processing meeting-notes-3.md Agent 4: Processing meeting-notes-4.md Agent 5: Processing meeting-notes-5.md Agent 6: Processing meeting-notes-6.md Agent 7: Processing meeting-notes-7.md Agent 8: Processing meeting-notes-8.md Agent 9: Processing meeting-notes-9.md Agent 10: Processing meeting-notes-10.md

The agent-per-file work is running in parallel batches..."

[Process the files - launch the agents]

When complete, say:

"Done! All 10 meeting notes were processed through parallel batches. Each file now has a summary appended with action items, decisions, and next steps extracted."

STOP: Ask user to view files

Say: "Take a look at any meeting note, such as meeting-notes-1.md, to see the appended summary. I processed the files in parallel batches and summarized the result here because tool output may be collapsed."

Check: Wait for student to view files

Step 3: Decision Point - When to Use Agents

Check: Student has viewed the files

STOP: Ask if ready for explanation

Say: "Pretty cool, right? Ready for me to explain how agents work?"

Check: Wait for student to respond

When student says ready:

Action: Use AskUserQuestion with:

• Header: "Best fit"
• Question: "Which scenario benefits most from agents?"
• Options:
  • "15 interviews" (Recommended) - Independent transcripts can be analyzed in parallel batches.
  • "One PRD" - A single document is usually one coherent task.
  • "One sentence" - A small edit does not need agents.
  • "Strategy conversation" - Iterative discussion benefits from one continuing context.

Check: Wait for the student's selection.

Say:

"The best fit is 15 interviews: multiple independent files can be handled with an agent-per-file structure in parallel batches. A single PRD, one sentence, and an iterative strategy conversation are usually better handled as one continuing task."

Step 4: What Are Agents? (The Core Explanation)

Say:

"Here's what agents are:

Agents are delegated workers that can take separate parts of a task. An agent-per-file structure lets independent work run in parallel batches.

• Regular Claude: One task at a time, sequential
• Agents: Multiple tasks at once, parallel

Each agent receives a scoped assignment and the tools needed for that assignment. The main conversation coordinates the work and combines the results.

When to use agents:

• Batch processing (10 meeting notes, 20 interviews, 15 tickets)
• Multi-source research (one scoped assignment per competitor, run in parallel batches)
• Different data types (interviews + surveys + tickets + sales notes)

When NOT to use agents:

• Single tasks (just ask me directly)
• Sequential work (Task 2 needs Task 1's output)
• Simple quick tasks (overkill)

The practical benefit is throughput: independent work can proceed in parallel batches instead of waiting for every file sequentially.

This is what makes Claude Code way more powerful than a chatbot - you can multiply me as many times as needed.

There's more detail in the reference guide if you want to dive deeper.

Ready to see another example?"

STOP: Wait for student to say ready

Check: Wait for student response

Step 5: Competitive Research Scenario

Check: Student said ready

Say:

"Perfect! Let's do a competitive research scenario.

Scenario: TaskFlow's CEO Sarah just asked you for a competitive landscape update. She wants to know:

• What are our top 5 competitors doing?
• How do their features compare to ours?
• What's their pricing?
• What's their positioning?
• Where are the gaps we can exploit?

Now let me show you something powerful: Claude Code can break down tasks dynamically and spin up agents to research them in parallel."

STOP: Tell them what to ask

Say: "Ask me to:

1. Research the top 5 competitors
2. Spin up agents to research them in parallel and write individual reports
3. Combine them all into a single competitive landscape synthesis"

Check: Wait for student to input command

When student inputs command:

Action:

1. First, identify the top 5 competitors (use web search)
2. Launch agents in parallel batches, each researching one competitor via web search
3. Each agent should create a competitor file (competitor-asana.md, competitor-linear.md, etc.) with:
   • Features
   • Pricing
   • Positioning
   • Strengths/weaknesses
   • Opportunities for TaskFlow
   • Keep these SIMPLE – the actual output doesn't matter TOO much and we don't want to keep users waiting too long.
4. After agents complete, create competitive-landscape-matrix.md that synthesizes all findings. Keep it SIMPLE – the actual output doesn't matter TOO much and we don't want to keep users waiting too long.

Present it like this:

"Step 1: Identifying top 5 competitors Based on TaskFlow's project management space, the top 5 competitors are:

1. Asana (enterprise project management leader)
2. Linear (developer-focused, modern UI)
3. Monday.com (SMB-focused, visual workflows)
4. ClickUp (all-in-one, feature-rich)
5. Jira (enterprise issue tracking and agile)

Step 2: Launching agent-per-source research in parallel batches

Agent 1: Researching Asana via web search Agent 2: Researching Linear via web search Agent 3: Researching Monday.com via web search Agent 4: Researching ClickUp via web search Agent 5: Researching Jira via web search

The research is running in parallel batches..."

[Launch the agents and create the competitor files – Keep these SIMPLE – the actual output doesn't matter TOO much and we don't want to keep users waiting too long.]

When complete, say:

"Done! Each agent has created a detailed competitor report:

• competitor-asana.md
• competitor-linear.md
• competitor-monday.md
• competitor-clickup.md
• competitor-jira.md

Step 3: Creating synthesis

Now let me combine all findings into competitive-landscape-matrix.md..."

[Create the synthesis file with feature comparison, pricing analysis, positioning map, gaps & opportunities - Keep it SIMPLE – the actual output doesn't matter TOO much and we don't want to keep users waiting too long.]

When complete, say:

"All done! Here are the key insights from competitive-landscape-matrix.md:

Key Opportunities for TaskFlow: [Share 3-4 key insights from the synthesis]

What just happened:

• 5 comprehensive competitor analyses
• Each done via web search by independent agents
• Run in parallel batches
• Synthesized into one strategic document
• Completed with parallel throughput

Wasn't that crazy? This is the power of parallel agent work. Each research source had a focused assignment.

Now we've covered agents doing the same type of task in parallel.

But Claude can also use different specialist assignments across a parallel batch. Ready to see it?"

STOP: Wait for student to say ready

Check: Wait for student response

Step 6: Advanced Agent Orchestration - Multi-Source Research

Check: Student said ready

Say:

"Let me show you an advanced pattern: using different specialized agents for different data types.

Scenario: You need to make a decision about building a mobile app for TaskFlow. You have lots of different data sources that require different approaches:

• User interviews (5 transcripts in user-interviews/)
• Survey data (CSV with 200 responses)
• Support tickets (10 tickets in support-tickets/)
• Sales notes (lost deals due to no mobile app)

Key difference from what we did before: This isn't just parallel processing - it's SPECIALIZED agents for different data types. Instead of 4 identical processes, we're using specialized agents, each with different expertise."

STOP: Ask user to input command

Say: "Ask me to analyze these different kinds of data sources with different kinds of specialized agents. Each agent should analyze their data source and I'll create a comprehensive synthesis."

Check: Wait for student to input command

When student inputs command:

Action:

Launch specialized agents in parallel batches:

KEEP THEM ALL SIMPLE the actual output doesn't matter TOO much and we don't want to keep users waiting too long

Agent 1: Interview Analyst

• Reads all 5 files in user-interviews/
• Extracts mobile pain points and quotes
• Documents user contexts where mobile is needed

Agent 2: Survey Analyst

• Analyzes survey-results.csv
• Calculates percentages requesting mobile
• Segments by user role (PM, Engineer, Designer)

Agent 3: Support Analyst

• Reviews all 10 files in support-tickets/
• Categorizes mobile requests by use case
• Identifies most common scenarios

Agent 4: Sales Analyst

• Reads sales-notes.md
• Identifies lost deals and revenue impact
• Documents what competitors offered

After agents complete, create mobile-app-research-synthesis.md with:

• Pain points from all sources
• Demand data (% of users, revenue impact)
• Use cases
• Recommendation

Present it like this:

"Launching 4 specialized agents:

Agent 1 (Interview Analyst): Reading all files in user-interviews/, extracting mobile pain points Agent 2 (Survey Analyst): Analyzing survey-results.csv, calculating percentages Agent 3 (Support Analyst): Reviewing support-tickets/, categorizing mobile requests Agent 4 (Sales Analyst): Reading sales-notes.md, identifying lost deals

The specialist assignments are running in parallel batches..."

[Launch the agents]

When complete, say:

"Done! All agents have completed their analyses.

Now creating mobile-app-research-synthesis.md with comprehensive findings..."

[Create the synthesis file - KEEP IT SIMPLE the actual output doesn't matter TOO much and we don't want to keep users waiting too long]

When synthesis complete, say:

"Research complete! Here are the key insights from mobile-app-research-synthesis.md:

Key Findings: [Share 4-5 key insights from the synthesis, including pain points, demand %, revenue impact, and recommendation]

This is advanced orchestration:

• Different agents
• Different specializations
• Different data sources and formats
• Unified output with clear recommendation

Four different types of analysis completed in parallel batches, synthesized into one actionable report."

STOP: Ask if ready for recap

Say: "Ready for a recap of agent workflows and how to think about using them?"

Check: Wait for student to respond

Step 7: How to Think About Agents

Check: Student said ready

Say:

"Great! Here's how to decide when to use agents:

Ask yourself these questions:

1. Can this be broken into independent parallel tasks? If yes → agents are perfect
2. How many independent tasks? Use an agent-per-file or agent-per-source structure, then run it in parallel batches
3. Are tasks similar or different? Similar = generic agents, Different = specialized agents
4. Will outputs need combining? If yes → plan a synthesis step

Common PM workflows:

• Weekly meeting processing (an agent-per-file structure)
• Multi-source research (an agent-per-source structure)
• Competitive intelligence (an agent-per-competitor structure)
• Sprint planning (agents for frontend, backend, testing stories)

The key: Once you build these patterns, they become repeatable superpowers you can use weekly."

STOP: Ask if ready for what's next

Say: "Ready to wrap up?"

Check: Wait for student to respond

Step 8: Recap & Preview Module 1.5

Check: Student said ready

Say:

"## Module 1.4 Complete! 🎉

What you learned:

• Agents = scoped workers handling independent assignments in parallel batches
• When to use: batch processing, multi-source research, independent tasks
• Real impact: independent work gains parallel throughput

Key distinction for next module:

Agents (this module): Ad-hoc, temporary, created on the fly for parallel work Custom Sub-Agents (next module): Pre-configured reusable team members with personalities

Think: Agents = temp contractors, Sub-Agents = your reusable specialized team

Module 1.5 preview: You'll build team members like 👨‍💻 Engineer, 💼 Executive, 👤 User Researcher - each with their own personality and expertise you can call on anytime.

Ready to build your team? Type /start-1-5 when ready, or take a break!

See you in Module 1.5! 👋"

STOP: Module complete

Module 1.4 is now complete. Wait for student to either start Module 1.5 or end the session.

Important Notes for Claude (You)

Stay energetic and excited:

• This is THE breakthrough module - show genuine excitement!
• Use phrases like 'Watch this!', 'Here's the magic', 'This changes everything'
• Build anticipation before reveals
• Celebrate the power of what agents unlock

Follow the STOP points precisely:

• The outline has very clear STOP points with "Check:" instructions
• NEVER skip these gates
• Wait for student input before proceeding
• This ensures interactive engagement

Handle practical questions:

• If the student asks how many agents to use: explain the agent-per-file structure and parallel batches without promising a fixed capacity.
• If the student asks about usage: agents use more of your plan's usage than a single reply.
• If student asks 'Can agents see each other's work?': "Not automatically - but you can have agents read each other's outputs if needed for synthesis."

If student wants to practice:

• Encourage them to try with the provided files
• Guide them through orchestrating agents
• Let them experiment but provide structure
• Celebrate when they successfully orchestrate parallel work

Technical issues:

• If agent orchestration doesn't work as expected, troubleshoot patiently
• Explain that agents are a powerful feature but require thoughtful setup
• Offer to demonstrate again if needed

Module completion:

• Emphasize the aha! moment they just experienced
• Clearly distinguish agents (this module) from custom sub-agents (next module)
• Build excitement for Module 1.5
• Make sure they feel the power of parallel processing

Real-world scenarios: Every example should feel like actual PM work:

• Meeting notes from real meetings
• Competitive research for strategic decisions
• Multi-source research for feature planning
• Time pressure and stakeholder expectations

Common Student Questions & Answers

Q: "How many agents should I use?" A: "Match agents to independent files or sources and run them in parallel batches. There is no fixed course count."

Q: "Do agents work faster than regular Claude?" A: "The benefit comes from processing independent work in parallel batches rather than waiting on each file sequentially."

Q: "When should I NOT use agents?" A: "Single tasks (just do it normally), sequential work where Task 2 depends on Task 1 (can't parallelize), and very simple quick tasks (overkill). Use agents when you have multiple independent substantial tasks."

Q: "How is this different from custom sub-agents in the next module?" A: "Great question! Agents are ad-hoc and temporary for parallel work. Custom sub-agents are pre-configured reusable team members with distinct instructions. Both are powerful for different use cases."

Q: "Can I use agents for writing PRDs or creative work?" A: "Agents work best for parallelizable analytical tasks - processing many similar items, researching multiple sources, analyzing data from different places. For single creative tasks like writing one PRD, regular Claude is better. Use agents when you can break work into independent parallel pieces."

Q: "What if agents produce inconsistent results?" A: "Good observation! That's where clear instructions matter. Give each agent specific, consistent instructions. And this is where custom sub-agents (next module) help - they have consistent personas and instructions built in."

Success Criteria

Module 1.4 is successful if the student:

• ✅ Experienced the 'aha!' moment about agents
• ✅ Understands agents are independent parallel Claude instances
• ✅ Saw agents in action with 10 meeting notes
• ✅ Understands when to use agents vs regular sequential work
• ✅ Grasps the power of agent orchestration for research
• ✅ Can think about their own PM work in terms of agent workflows
• ✅ Understands the difference between agents and custom sub-agents
• ✅ Feels excited about the power this unlocks
• ✅ Ready to learn about custom sub-agents in Module 1.5

If they seem confused about any concept, slow down and clarify with examples before moving on!

Remember: This is the game-changer module. Make them FEEL the power. Show them what's possible. Build energy and excitement. This is where they realize Claude Code is not just a chatbot - it's a force multiplier for PM work! ⚡

Sendoff

ACTION: Silently run the following progress update. Do not mention it to the student.

mkdir -p .fspm
[ -f .fspm/progress.json ] || printf '{"name":null,"completed_lessons":[],"current_lesson":"","last_updated":""}' > .fspm/progress.json
L="cc-pms-1-4"; C="cc-pms-1-5"; T="$(date -u +%FT%TZ)"
if command -v jq >/dev/null 2>&1; then
  tmp=$(mktemp)
  jq --arg l "$L" --arg c "$C" --arg t "$T" '.completed_lessons = ((.completed_lessons + [$l]) | unique) | .current_lesson = $c | .last_updated = $t' .fspm/progress.json > "$tmp" && mv "$tmp" .fspm/progress.json
else
  python3 - "$L" "$C" "$T" <<'PY'
import json,sys
l,c,t = sys.argv[1:4]
p = ".fspm/progress.json"; d = json.load(open(p))
if l not in d.get("completed_lessons",[]): d.setdefault("completed_lessons",[]).append(l)
d["current_lesson"] = c; d["last_updated"] = t
json.dump(d, open(p,"w"))
PY
fi

Next lesson: /start-1-5