You'll walk away with
- What an agentic coding tool is and how Claude Code differs from claude.ai (it touches your files, terminal, and codebase directly)
- The Explore-Plan-Code-Commit workflow with Plan Mode (
Shift + Tab) as the safe place to course-correct before any code is written - How to manage the context window with
/compact,/clear,/context, and what the trade-offs are - How to write a CLAUDE.md that gives Claude persistent project memory; the project vs user hierarchy
- The five customization surfaces: Subagents, Skills, MCP, Hooks, and CLAUDE.md, and which one to reach for when
- Why Hooks are the deterministic answer when CLAUDE.md instructions aren't enough (
if it must happen every time, don't put it in a prompt)
Read these first
Lesson outline
Every lesson from Claude Code 101 with our one-line simplification. The Skilljar course is the source; we summarize.
| # | Skilljar lesson | Our simplification |
|---|---|---|
| 1 | What is Claude Code? | An agentic coding tool that reads your codebase, edits files, runs commands; available in terminal, VS Code, JetBrains, Desktop, and web. |
| 2 | How Claude Code works | An LLM in a real-time loop with tool access; agent means software that takes actions in its environment to reach a goal. |
| 3 | Installing Claude Code | Install via npm, pip, or the official installer; sign in with your Anthropic account; verify in terminal. |
| 4 | Your first prompt | First-prompt mechanics: how Claude Code asks for permission, how it streams output, how to stop it. |
| 5 | The explore → plan → code → commit workflow | Use Plan Mode (Shift + Tab) to read-only explore and produce a plan; review and revise before any code is written; then code, then commit. |
| 6 | Context management | Use /compact to summarize when nearing limit; /clear to start fresh; /context to inspect what's filling the window. |
| 7 | Code review | Run a code-reviewer subagent before commit; fresh-eyes review without the main session's bias. |
| 8 | The CLAUDE.md file | Project-level Markdown that's auto-appended to your prompt every session; project + user hierarchy; commit it for team. |
| 9 | Subagents | Specialized helpers in their own context window; built-in (General, Explore, Plan) plus custom ones in .claude/agents/. |
| 10 | Skills | Reusable instruction packages; lighter context cost than MCP because only name + description load until invoked. |
| 11 | MCP | Open standard for connecting external tools (HTTP or stdio); add with claude mcp add; scope local/user/project; watch context cost. |
| 12 | Hooks | Deterministic commands that run on lifecycle events (PreToolUse, PostToolUse, Stop, Notification); use exit code 2 to block. |
| 13 | Course quiz | 13-question Skilljar quiz; not exam-relevant on its own but useful as a self-check on the five customization surfaces. |
The course in 7 paragraphs
Claude Code is described in Lesson 1 as an agentic coding tool that understands your codebase, edits your files, runs commands, and integrates with your existing developer tools. The framing matters: Claude Code is not a smarter chat box, it is an agent. The course defines an AI agent as software that interacts with its environment and performs actions to reach a goal, and that definition lands directly on the D1 exam questions about agentic loops. Three ground rules govern every session: the context window is finite, Claude asks for permission by default, and Claude can make mistakes, so staying in the loop is not optional.
The single most-tested concept in this course is the Explore, Plan, Code, Commit workflow in Lesson 5. The course is explicit: If you take one thing away from this course, let it be this workflow. The fastest way to do the first two steps is Plan Mode, which you toggle with Shift + Tab until you see Plan Mode under the input. In plan mode Claude can read but cannot edit, so it can gather context safely and produce a plan you review before any code is written. This is the cheapest place to course-correct; once code lands, every fix is more expensive.
Context management (Lesson 6) is the rest of the D1 surface. The context window is Claude's working memory, and every prompt, file read, and tool call eats into it. When you approach the limit, Claude compacts the conversation: it summarizes important details and drops noise. Compaction can lose details, so you can also run /compact manually before that happens, /clear to start fully fresh, and /context to inspect what is consuming space. The three habits the course pushes: be specific (vague prompts cost MORE context, not less), manage MCP servers (they load all tools by default), and use subagents for where is X? questions.
CLAUDE.md (Lesson 8) is the persistent-memory primitive. It is a Markdown file at your project root that Claude Code automatically appends to every prompt at session start. Treat it as an onboarding script: stack, commands, code style, anything Claude would otherwise rediscover. The file has a hierarchy: project-level (./CLAUDE.md, committed to version control, shared with the team) and user-level (your config folder, personal preferences across projects). The course's strongest tip: start without one and add to it whenever you find yourself correcting Claude on the same thing twice. That keeps the file compact and signal-rich.
The customization story is the five surfaces you will be tested on. Subagents (Lesson 9) run in their own context window and return only a summary; ship built-in (General, Explore, Plan) plus custom ones as Markdown files in .claude/agents/. Skills (Lesson 10) are procedural packages that only load their full body when Claude decides to invoke them, so they are lighter on context than MCP. MCP (Lesson 11) connects external tools; you add servers with claude mcp add, scope them local/user/project, and watch the context cost because MCP loads all tool definitions by default. Hooks (Lesson 12) are the deterministic escape hatch: shell commands that fire on lifecycle events (PreToolUse, PostToolUse, UserPromptSubmit, Stop, Notification). The course's mic-drop line: `if something needs to happen every time without fail, do not put it in a prompt; put it in a hook`.
The mental model the course teaches for picking the right surface: CLAUDE.md for Claude should always know this; Skills for Claude should follow this procedure when relevant; MCP for Claude needs access to this external system; Subagents for this side-task should not pollute my main context; Hooks for this must happen, no exceptions. MCP and Skills both add capability, but Skills are cheaper on context because only the name and description load until use; MCP loads all tool definitions upfront. If your MCP tools exceed 10% of the context window, Claude Code automatically switches to tool search mode, which discovers tools on demand but is less reliable.
Take Claude Code 101 right after Claude 101. It is the second-most-load-bearing course on Pillar 4 and supplies vocabulary the Subagents, Agent Skills, and MCP courses all assume. The five customization surfaces, the Explore-Plan-Code-Commit loop, and the deterministic-hook rule are the three exam anchors you should be able to recite without notes. After this course, you have enough mechanical fluency to take Claude Code in Action (integration patterns), Subagents Intro (deeper context isolation), Agent Skills Intro (composable procedure), and MCP Foundations (external-tool surface) in any order.
5 customization surfaces in Claude Code (and which to pick when)
Lessons 8 through 12 cover the five surfaces. Picking the right one is the most-tested practical skill in the course.
- CLAUDE.md, persistent project memory
Use when Claude should always know something about the project (stack, commands, conventions). Auto-appended to every session. Cheapest, most universal surface.
Concept: claude-md-hierarchy ↗ - Subagents, context isolation
Use when a side task should not pollute your main context. Built-in (General, Explore, Plan) or custom ones in
Concept: subagents ↗.claude/agents/. Returns only a summary. - Skills, procedural know-how
Use when there's a repeatable workflow Claude should execute consistently. Lighter on context than MCP because only name and description load until invoked.
Concept: skills ↗ - MCP, external tools and data
Use when Claude needs to reach an external system (Linear, GitHub, internal database). Add with
Concept: mcp ↗claude mcp add; scope local/user/project. Watch the context cost. - Hooks, deterministic enforcement
Use when something must happen every time, with no exceptions: auto-formatting, blocking dangerous commands, audit logging. Configured in
Concept: hooks ↗settings.json; PreToolUse exit code 2 blocks the action.
6 takeaways with cross-pillar bridges
Claude Code is an agentic coding tool: an LLM in a real-time loop with direct access to your files, terminal, and codebase. Permission-gated by default, but staying in the loop catches its mistakes.
The Explore-Plan-Code-Commit workflow with Plan Mode (Shift + Tab) is the highest-leverage habit in the course; course-correcting in plan mode is far cheaper than fixing committed code.
Context management is mechanical: /compact to summarize, /clear to start fresh, /context to inspect; vague prompts cost MORE context than specific ones because Claude has to explore.
CLAUDE.md is auto-appended to every session; the project file goes in version control, the user file is personal. Start without one and add only what you find yourself repeating.
Skills are cheaper on context than MCP because only the name and description load until invoked; MCP loads all tool definitions upfront, which can dominate the context window.
Hooks are the deterministic escape hatch: if something must happen every time, don't put it in a prompt; put it in a hook. PreToolUse with exit code 2 blocks the action and feeds back stderr.
How this maps to the CCA-F exam
3 hand-picked extras
These amplify the Skilljar course beyond what the course itself covers. Each was picked for a specific reason.
Claude Code: Best practices for agentic coding
Anthropic's engineering write-up on the workflow patterns this course teaches; deeper rationale behind Plan Mode, CLAUDE.md, and the customization surfaces.
Read source ↗Claude Code documentation: Hooks
Canonical reference for the hook event types and exit-code semantics; pair with Lesson 12 when you start authoring your first PreToolUse hook.
Read source ↗Claude Code documentation: Memory (CLAUDE.md)
The hierarchy spec for CLAUDE.md (project, user, enterprise) and import syntax; the lesson abbreviates this.
Read source ↗Concepts in this course
Agentic loops
What Claude Code runs at its core
Concept: agentic-loops ↗Plan mode
Read-only exploration before code
Concept: plan-mode ↗Context window
What `/compact` and `/clear` manage
Concept: context-window ↗CLAUDE.md hierarchy
Project and user memory layers
Concept: claude-md-hierarchy ↗Subagents
Isolated-context delegation surface
Concept: subagents ↗Skills
Procedural extension surface
Concept: skills ↗Model Context Protocol
External-tool extension surface
Concept: mcp ↗Hooks
Deterministic enforcement surface
Concept: hooks ↗Where you'll see this in production
Code generation with Claude Code
End-to-end Explore-Plan-Code-Commit workflow on a real feature
Scenario: code-generation-with-claude-code ↗Developer productivity agent
Customizing Claude Code with subagents and skills for a recurring team workflow
Scenario: developer-productivity-agent ↗Claude Code for CI/CD
Hooks and headless mode for deterministic pipeline behavior
Scenario: claude-code-for-cicd ↗Other course mirrors you may want next
8 questions answered
Phrased as the way real students search. Tagged by intent so you can scan to what you actually need.
ComparisonWhat is Claude Code and how is it different from claude.ai?
DefinitionWhat is the Explore Plan Code Commit workflow in Claude Code?
Shift + Tab for read-only safety), Code executes the plan with Claude editing files, Commit runs a code-reviewer subagent and pushes. Course-correcting in plan mode is far cheaper than fixing committed code.How-toHow do I manage the context window in Claude Code when it gets full?
/compact summarizes important details and drops noise (run manually before auto-compaction loses things you wanted), /clear wipes context to start fully fresh, /context shows you a visual breakdown of what's consuming space. Vague prompts cost MORE context, not less, because Claude has to explore the codebase to figure out what you meant.How-toWhat goes in a CLAUDE.md file and where should I put it?
~/.claude/CLAUDE.md for personal preferences across projects. The strong recommendation from Lesson 8: start without one and add only what you find yourself correcting Claude on twice. Run /init when you're ready to generate one.ComparisonWhat's the difference between Skills and MCP servers in Claude Code?
TroubleshootWhy is my Claude Code session forgetting things between turns?
/compact manually before auto-compaction so you control what gets summarized. Second, you're starting fresh sessions without a CLAUDE.md; anything Claude should always know belongs in CLAUDE.md so it's loaded automatically every session.