Lesson 33: Checkpoint — Integrations Review

Day 33 of 50 · ~15 min read · Phase 4: Integrations

You've completed a full week on integrations — MCP, IDE integration, hooks, testing, debugging, extended thinking, and checkpointing.

Before moving to the final phase, let's verify you understand the landscape. Answer the questions below. Score yourself: 1 point per correct answer. 16/16 means you're ready.

Questions 1-2: Phase 1 Review

Question 1: In Lesson 2, we said Claude Code solves the problem of... what?

Claude Code solves the problem of developers being slow at executing routine tasks. It doesn't write your code for you; it augments you with an agent that can read, edit, and iterate on code while you focus on decisions.

Question 2: What's the difference between the Bash tool and the Edit tool?

The Bash tool runs commands in the terminal and shows you the output. The Edit tool makes changes to files. Claude uses both: Bash to explore, verify, run tests, and Edit to change code. You can't edit files with Bash; you edit them with Edit.

Questions 3-4: Phase 2 Review

Question 3: What's a CLAUDE.md file and why would you create one?

CLAUDE.md is a file in your project that tells Claude Code about your project's rules, conventions, and context. You create one to:

Set coding standards (naming conventions, patterns, structure)
Define security rules (don't touch certain files)
Provide project context (architecture, tech stack, team conventions)
Configure custom slash commands

It's like an instruction manual for Claude so it understands your project better.

Question 4: If you create a slash command /lint, how does that differ from a hook?

A slash command is AI-driven: Claude sees it's available and can choose to invoke it. A hook is deterministic: it runs automatically every time a trigger event occurs (PostToolUse, SessionStart, etc.), with no decision-making needed.

Skills/commands are reactive. Hooks are automatic.

Questions 5-7: Phase 3 Review

Question 5: You're refactoring a function that's called in 12 different places. What's the right first step?

Search for all references first. Use Grep or Glob to find all places the function is called. Then plan coordinated edits across all files. This prevents "surprise breakages" where you edit one file and break others. It's called dependency discovery (Lesson 9).

Question 6: When is it better to use git commands in Claude Code versus doing git work manually?

Use Claude Code for git when you want to:

Stage and commit changes with good messages
Create branches and switch between them
Create pull requests automatically
Review diffs and understand what changed

Use it when Claude can see the context and write meaningful commits. Git is just another tool that Claude can use; the value is in Claude reasoning about what to commit and why.

Question 7: What's the purpose of a skill (a reusable slash command)?

A skill is a reusable, saved workflow that you invoke with a slash command. It's how you encode domain-specific knowledge into Claude Code. For example, /deploy might run tests, build the project, and push to production. You create skills for tasks you do repeatedly, so you don't have to retype instructions each time.

Questions 8-16: Phase 4 Review

Question 8: What does MCP stand for and what problem does it solve?

MCP = Model Context Protocol. It's a standard protocol that lets Claude Code talk to any external service (Slack, GitHub, databases, etc.) without custom integrations. Instead of Anthropic building 100 custom integrations, any service can write an MCP server once, and Claude can talk to it.

Question 9: You're using VS Code. Should you use the Claude Code extension there, or use the terminal?

Use the IDE extension for quick edits and code review. Use the terminal for deep exploration, refactoring, and complex reasoning. Most developers use both: IDE for "I'm in this file, let Claude help," terminal for "I need to understand this system and make coordinated changes."

Question 10: How is a hook different from a skill?

Skills are AI-driven slash commands. Claude chooses when to invoke them. Variable.
Hooks are deterministic scripts that run automatically at specific moments (PostToolUse, SessionStart, etc.). 100% consistent, no decision-making.

Use hooks for things that should always happen (linting, formatting, testing). Use skills for things that sometimes happen (running deployment, checking a specific service).

Question 11: In Lesson 28, we said testing with Claude inverts what risk model?

The normal risk model is: hope the code is correct. With Claude + testing, the model inverts: define correctness up-front through tests, and Claude's job is making the tests pass. Tests become the objective standard, not Claude's assurance that it's "probably fine."

Question 12: You've got a bug and a stack trace. What's the advantage of debugging with Claude Code versus doing it manually?

Claude can read your entire codebase at once and trace bugs to their root cause without you pointing it at the right file. You just share the error, and Claude:

Reads the file mentioned in the stack trace
Traces backwards through the call stack
Reads all the related files
Spots the root cause
Implements a fix and tests it

Manual debugging forces you to search. Claude reasoning across the whole system means it spots patterns you'd miss.

Question 13: When should you use extended thinking in Claude Code?

Use extended thinking for:

Complex architectural decisions (how should we refactor this?)
Subtle bugs (why is this test flaky?)
Multi-system planning (how do these parts fit together?)
High-stakes work (where a mistake is costly)

Skip it for:

Quick edits
Straightforward tasks
Low-stakes work
When you want fast iteration

Extended thinking trades speed for reasoning depth.

Question 14: What happens when you rewind in a Claude Code session?

Rewinding instantly reverts your code to a previous checkpoint. All changes since that checkpoint are undone. You can then ask Claude to try a different approach from that point. It's like hitting undo on the whole conversation.

Use it when you realize you're going the wrong direction.

Question 15: What's a fork, and when would you use it instead of rewinding?

A fork creates a parallel branch of your conversation. You can explore a different approach on the fork while keeping your original work safe. Use forking when:

You want to compare two approaches before deciding
You're not sure which direction is better yet
You want to keep both versions available

Use rewinding when you just want to discard recent changes and start fresh from a checkpoint.

Question 16: You're about to tackle a complex feature using Claude Code. Walk through a best-practice workflow using tools from all of Phase 4.

Write tests first (Lesson 28). You and Claude agree on correctness.
Configure a hook (Lesson 27) to run tests automatically after edits.
Use extended thinking (Lesson 30) for architectural decisions.
Start implementation with Claude. The hook runs tests after each edit.
When tests fail, debug together (Lesson 29). Claude reads the error, traces the code, proposes a fix.
If stuck, fork the conversation (Lesson 31) to explore an alternative approach while keeping the original safe.
Switch between terminal (for deep work) and IDE (for quick edits) (Lesson 26).
Use MCP integrations (Lesson 25) if you need to interact with external services (GitHub issues, Slack, etc.).
Review the final code and iterate on clarity and style.

Result: A well-tested, well-reasoned feature built in partnership with Claude Code.

Your Score: ___ / 16

14-16: You're ready. You understand integrations deeply and can use the full toolkit.
11-13: You've got the concepts down. Review a few areas and you'll be solid.
8-10: You understand the basics. Re-read the lessons that were fuzzy and try again.
Below 8: Don't worry. Integrations are complex. Re-read the lessons, do the Try Its, and take the checkpoint again.

What Comes Next

You've finished Phase 4: Integrations. You now understand:

MCP — connecting to external services
IDE integration — choosing where Claude works
Hooks — deterministic automation
Testing — defining correctness before implementation
Debugging — reasoning across your entire codebase
Extended thinking — allocating extra reasoning on hard problems
Checkpointing and forking — fearless exploration

Phase 5 (Lessons 34-50) covers advanced topics like production patterns, enterprise workflows, security, optimization, and capstone projects.

You're building real skills. Keep going.

← Back to Curriculum · Lesson 34 →