2.5 Choosing Your Tools

The AI tool landscape looks overwhelming because it's marketed one product at a time. Zoom out and it's just four layers. This lesson gives you the map, explains where Claude Code sits and why this course builds on it, and — more importantly — teaches you to evaluate any new tool in five minutes, because new ones will keep coming.

What you will learn

• Sort any AI product into one of four layers: model, interface, agent, platform.
• Explain why this course teaches through Claude Code, and what transfers when tools change.
• Evaluate a new AI tool quickly with a four-question filter.

Builder principle

Learn stable concepts through a concrete tool. Then prove you can translate them.

The four layers

Layer 1 — Models. The engines: Claude, GPT, Gemini, Llama. Everything else is built on these. Differences that matter to you: capability, speed, cost, and context size. Model families come in tiers (in Claude's line: Haiku = fast and cheap, Sonnet = the workhorse, Opus and beyond = maximum capability) — and matching tier to task is a real cost skill you'll use in Chapter 11.

Layer 2 — Chat interfaces. Claude.ai, ChatGPT, Gemini. A conversation wrapped around a model. Perfect for thinking, drafting, learning — you'll never stop using these. But they're advisors, not workers (Lesson 1.2).

Layer 3 — Agents. Models with tools: they can act on files and systems, observe results, and continue in a loop. Claude Code, IDE agents, and other CLI agents live here. This layer is where this course lives, because it makes the consequences and verification of model output concrete.

Layer 4 — Platforms and glue. App builders, workflow automators (n8n, Zapier), and the connective standards — most importantly MCP, the open protocol that lets any agent use any tool (Chapter 8). The standards matter more than any product on this layer.

Why Claude Code, specifically

An honest accounting, since you should demand one:

1. It makes the agentic loop visible. In the terminal, you can watch it gather, act, and verify, which makes it a useful learning instrument.
2. The full stack we teach is native to it. CLAUDE.md and memory, Skills, MCP, hooks, subagents — Chapters 5 through 10 map one-to-one onto real features, so nothing here is theoretical.
3. It exposes a broad working stack in one place. That lets this course connect context, tools, permissions, and evaluation without switching products every lesson.
4. The concepts can transfer. Context engineering, briefing, verification, and orchestration recur across tools. Exact file names, commands, permission models, and memory behavior do not; translating them is part of the skill.

Concepts vs. this course's implementation

Transferable concept	Claude Code implementation here	What to re-check elsewhere
Persistent project instructions	CLAUDE.md	Instruction-file name, precedence, and who can edit it
Reusable capability	Skills in .claude/skills/	Packaging format, activation rules, and side-effect controls
Tool connection	MCP servers and CLIs	Protocol support, authentication, scopes, and approval model
Event-driven guardrail	Hooks and settings	Available events, execution identity, and failure behavior
Delegated parallel work	Subagents, agent teams, worktrees	Context isolation, filesystem isolation, cost, and merge workflow
Human verification	Diffs, tests, acceptance pass	Evidence surface and what the tool may have changed outside it

At each translation, keep the intent and re-verify the mechanism. Similar labels do not guarantee identical security or behavior.

Watch

How I use LLMs — Karpathy's practical tour of the whole ecosystem (2 hr). The best single video for seeing how the layers fit together in real daily use.

The five-minute tool filter

New AI products launch weekly. Four questions sort the signal from the noise:

1. Which layer is it? Most "revolutionary" products are a thin wrapper on layer 1 or 2. Wrappers can be useful — but price them as wrappers.
2. What does it add to the loop? Better gathering (context)? Better acting (tools)? Better verifying (guardrails)? If you can't name the addition, there isn't one.
3. What's the lock-in? Can you export your work? Does it build on open standards (MCP, Git, plain files) or a proprietary island? Islands sink.
4. Would it still matter if the model under it changed? Tools that survive model swaps are infrastructure. Tools that don't are features.

Run the filter on everything — including this course's choices. Record where a choice passes, where it creates lock-in, and what you would need to retest after switching.

Your loadout for this course

• Claude Code — the primary tool. Installed in Setup.
• Claude.ai (chat) — your thinking partner: for questions, planning, and getting unstuck (the Lesson 1.5 protocol).
• Git + GitHub — the safety net and the portfolio. Chapter 3 makes them yours.
• A plain-text editor — for reading what your agent builds. VS Code is fine and free.

That's it. No fifteen-tool stack. Depth over breadth, always.

Try it now

Pick any AI tool you've seen hyped recently. Spend five minutes on its homepage and run the four-question filter in your journal.

Then the portability question: map one feature to the table above. Which concept transfers, and which implementation detail would you have to relearn?

Check your understanding

• Name the four layers and one example of each.
• Why does this course teach at layer 3 rather than layer 2?
• Which of the four filter questions detects wrappers? Which detects islands?
• What in your learning transfers if a different agent wins the market in two years?