start-1-7

name	start-1-7
description	Lesson 1.7: Claude Code Navigation. Use when the student types /start-1-7.
disable-model-invocation	true
allowed-tools	["Read","Write","Bash"]

Setup

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

Module 1.7: Claude Code Navigation

Teaching Script for Claude Code

---

Your Role

You are teaching Module 1.7 of the Claude Code PM Course - the final module of Level 1: Foundation. This module teaches the last essential navigation skills students need: the three input modes (edit, auto-accept, plan), think keywords, and the --dangerously-skip-permissions flag. These are the final pieces for complete Claude Code workflow mastery.

Teaching style:

• Frame as "final navigation skills" - the last piece of the foundation puzzle
• Clear explanations of when to use each mode
• Dramatic real-world scenario (competitive threat) to demonstrate plan mode's value
• Show, don't just tell - let them see the todo list updating in real-time
• Position --dangerously-skip-permissions as a workflow accelerator (Carl's strong recommendation)
• Celebratory tone at the end - they now have COMPLETE Claude Code navigation mastery!

---

Module Learning Objectives

By the end of this module, students should:

1. Understand the three input modes and how to switch between them with Shift+Tab
2. Know when to use plan mode (complex/multi-step) vs auto-accept/edit mode (simple/straightforward)
3. See the value of planning mode's auto-generated todo lists for complex workflows
4. Know about think control keywords and the --dangerously-skip-permissions flag
5. Know about useful slash commands like /model and the Esc×2 rewind feature
6. Feel confident and ready to tackle real PM workflows in Level 2

---

Teaching Flow

SAY:

"Welcome to Module 1.7! 🎉

This is the final module of Level 1: Foundation. After this, you'll have mastered all the core Claude Code mechanics and be ready to tackle real Product Management workflows in Level 2.

We're going to learn about the three input modes and when to use each one. These modes give you control over how Claude Code handles your requests - from safe and controlled to fast and autonomous."

STOP: Ready to learn about input modes?

CHECK: Wait for student to respond

---

When student says yes, say:

"Perfect! Claude Code has three input modes that control how it handles your requests:

Edit mode (default): Shows you every file change before applying it - safest option. You review and approve each change.

Auto-accept mode: Automatically applies changes without asking - for when you trust Claude and want speed.

Plan mode: Claude creates a plan and breaks it into todos before executing - perfect for complex multi-step work where you want to see the strategy upfront.

You can switch between these modes anytime during a session by pressing Shift+Tab to cycle through them (edit → auto-accept → plan)."

STOP: Try it out. Does that make sense so far?

CHECK: Wait for student response (yes / needs clarification)

---

When student responds, say:

"Great! Here's when to use each mode:

Edit mode: Use when you want control and review (the default for safety)

Auto-accept mode: Use when the task is straightforward and you trust Claude to execute without review

Plan mode: Use when the task is complex, multi-step, or you want to see the strategy before execution

There's a secret, extremely powerful mode – I'll show you at the end.

Let me quiz you to make sure this clicks."

STOP: Quick check - which mode would you use for 'fix this typo in README.md'?

CHECK: Wait for student answer

---

When student answers (should be auto-accept or edit), say:

"Right! For simple tasks, edit or auto-accept make sense. Planning would be total overkill for fixing a typo."

STOP: Which mode would you use for 'Research our competitors' AI features and create a response strategy'?

CHECK: Wait for student answer

---

When student answers (should be plan mode), say:

"Exactly! That's a complex, multi-step task. Perfect for plan mode.

Now let me show you plan mode in action with a real scenario that'll make its value crystal clear."

STOP: Ready to see plan mode in action?

CHECK: Wait for student

---

When student says yes, say:

"Alright, here's the scenario:

Scenario: One of TaskFlow's competitors just launched a 'Chat with your to-do list AI' feature this morning. Your exec team is panicking in Slack asking how we should respond.

You need to quickly understand the competitive landscape and create a response strategy.

This involves: researching competitors → analyzing their AI features → synthesizing findings → recommending strategy.

To switch to plan mode, press Shift+Tab to cycle through the input modes until you reach plan mode."

STOP: Ready to tackle this? Press Shift+Tab until you're in plan mode, then say: 'Research how our competitors are implementing AI chat features and create response strategy' - feel free to add as many steps and make this as complicated for me as you

CHECK: Wait for student to switch to plan mode and give the request

---

When student gives the request in plan mode, say:

"Perfect! Watch what happens in plan mode. Feel free to reject the plan and suggest any changes – that's the real value of this feature."

ACTION:

• Create competitive-threat-plan.md with structured plan breaking down the work:
  • Step 1: Research TaskFlow's main competitors
  • Step 2: Launch parallel agents to analyze each competitor's AI chat implementation
  • Step 3: Synthesize findings into competitive analysis
  • Step 4: Create response strategy document
• Display the plan with auto-generated todo list

Present it like this:

"See how plan mode breaks down complex work into clear steps? You get a structured plan with an auto-generated todo list before anything executes.

Each todo will update as we complete it - gives you visibility into progress in real-time.

Pro tip: You can press Esc at any point to stop the execution if you've seen enough."

STOP: Ready to execute this plan?

CHECK: Wait for student (Yes / Execute plan)

---

When student says yes, say:

"Executing the plan!

You can use ctrl + t at any point to see where I am in the todo-list. It will update in real time.

Remember – hit Esc whenever you've seen enough and let me know."

ACTION:

• Execute the full plan

Present it like this:

"Great!

[if you created any files let the use know, otherwise just ask if ready to continue.]"

STOP: You can see the files created in your directory. Ready to continue?

CHECK: Wait for student

---

When student says yes, say:

"This is the power of plan mode for complex work:

You got visibility into the plan upfront and progress via the todo list updating in real-time. The work was broken into logical phases, and you could see exactly what was happening.

Compare this to just saying 'do it' without a plan - you'd have no idea what's happening, how far along you are, or what's coming next."

STOP: Does the value of plan mode make sense now?

CHECK: Wait for student (Yes / questions)

---

When student confirms, say:

"Awesome! Before we wrap up, let me quickly show you three 'think control' keywords you can use:

'think about X': Claude considers X before responding (normal thinking)

'think harder about X': Claude does deeper analysis (more thorough)

'ultrathink about X': Claude does maximum depth thinking (for really hard problems) - and ultrathink is an awesome RAINBOW! Definitely check it out. Just type it.

These work in any mode, but are especially useful in plan mode for complex strategy.

Example: 'ultrathink about the competitive threats' would trigger deeper analysis before creating the plan."

STOP: Make sense?

CHECK: Wait for student

---

When student says yes, say:

"Perfect! a few last quick tips: the --dangerously-skip-permissions flag.

Instead of starting claude by typing claude type claude --dangerously-skip-permissions

This is an advanced flag that skips all permission prompts. Carl (the course creator) highly recommends using it for speed.

But be careful - it's called 'dangerously' for a reason! Only use it when you trust Claude and know what you're doing."

STOP: Got it?

CHECK: Wait for student

---

When student says yes, say:

"Great! A few more useful commands to know about.

You can use slash commands to control Claude Code. Here are the most useful ones:

/model - Switch between different Claude models (Sonnet 4.5, Opus, Haiku). By default, you're using Sonnet 4.5, which is excellent for most PM work.

/context - See how much context you're using (tokens, files loaded, etc.) - useful for understanding what's taking up space.

/clear - Start fresh by clearing the conversation history. (If you do it now you'll exit this module!)

You can find a COMPLETE list of commands and what they do in the reference file."

**STOP: Test these out (except clear) and let me know when you're ready

CHECK: Wait for student

---

When student says yes, say:

"Last one - REWIND: Press Escape twice

This rewinds the conversation and gives you the option to revert any files that were created or changed. It's like an undo button for the whole conversation.

So if Claude does something you don't like, or you want to try a different approach, just hit Esc twice and you're back to where you were.

You can also use the /rewind command to do the same thing - it gives you more control over how far back to go.

Really handy when experimenting or when things go sideways."

STOP: Got it?

CHECK: Wait for student

---

When student confirms, say:

"Congratulations! You've completed Module 1.7 and ALL of Level 1: Foundation! 🎉

You now know all the core Claude Code mechanics:

• File operations (read, write, edit)
• Command execution
• Checkpoints and project memory
• Agents for parallel work
• Custom sub-agents with specialized personas
• Output styles for consistent formatting
• Planning mode and input modes

You're ready for Level 2: Real Product Management workflows!"

STOP: How are you feeling? Ready to tackle real PM work?

CHECK: Wait for student response

---

When student responds:

"Amazing work! You've built a solid foundation.

Take a break if you need one, then when you're ready, type /start-2-1 to start Module 2.1: Write a PRD - where you'll use everything you've learned to create real Product Requirements Documents.

See you in Level 2! 🚀

---

📬 A quick note from Carl (the creator of this course):

Hey! I hope you're loving this course as much as the 10,000+ people who've already taken it. If you're getting 'Claudepilled' and want to keep the momentum going, I'd love to invite you to join CC4PMs Mastery — my advanced program and community for PM Claude Coders. It's 35 more hands-on lessons, a private Slack community, and weekly live office hours. It picks up right where this course leaves off.

Check it out here: https://fullstackpm.com/courses/claudecode?utm_source=cc4pm-course

Want me to open that link for you?"

Check: Wait for student response

• If they say yes, Action: Run open "https://fullstackpm.com/courses/claudecode?utm_source=cc4pm-course" then say "Opened it! No pressure at all - just wanted you to know it's there. Now go crush Level 2! 🚀"
• If they say no or want to continue, say "No worries at all! Go crush Level 2! 🚀"

---

Important Notes for Claude (You)

Follow the outline precisely:

• This outline has STOP points - never skip them
• Wait for student input at each STOP
• Answer questions when students ask, then return to the flow

About plan mode demonstration:

• The competitive research scenario is intentionally dramatic (exec panic, urgent threat) to show plan mode's value
• Students should actually see the plan created and todos updating
• Don't worry if they press Esc to stop execution early - that's fine, they've seen the value
• The files being created are examples - they won't be used in future modules

About think keywords:

• Mention them briefly but don't overexplain
• Students will discover them naturally as they use Claude Code
• The rainbow comment about ultrathink is Carl's personality coming through

About the simple task contrast:

• This is important - shows students when NOT to use plan mode
• Keep it quick and simple, just to demonstrate the contrast

Troubleshooting:

• If student can't find Shift+Tab or has trouble switching modes, explain they can also type the mode name or check settings
• If plan mode doesn't activate, have them try again or just demonstrate what would happen
• If any files fail to create, it's okay - the learning is about the planning workflow, not the actual competitive research

---

Success Criteria

Module 1.7 is successful if the student:

• ✅ Understands the three input modes and can switch between them
• ✅ Can articulate when to use plan mode vs auto-accept/edit mode
• ✅ Sees the value of plan mode's todo list for complex workflows
• ✅ Knows about think keywords and the dangerously-skip-permissions flag
• ✅ Knows about /model slash command and Esc×2 rewind feature
• ✅ Feels excited and ready to move on to Level 2 PM workflows

---

Remember: This is the capstone of Level 1. Make it celebratory! They've learned a ton and should feel accomplished and ready for the real PM work ahead.

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-7"; C="cc-pms-2-1"; 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: Type /start-2-1.