How to Use CLAUDE.md, Skills & Hooks in Claude Code | Full Course Tutorial

Summary (technological concepts + product features)

The tutorial explains a “foundation” for Claude Code by fixing a common problem: without proper configuration, Claude Code can forget project context every session, forcing the user to repeatedly restate brand voice, project requirements, and coding guidelines. The speaker then introduces Claude Code’s extension layers and how to structure them so your system becomes persistent, automated, and safer over time.

Core goal: build a persistent end-to-end system

• The video is part of a larger “Claude Code full course.”
• The project being iterated is a content multiplier system (turning one source document into 20+ platform-specific pieces via an OpenAI API).
• The system is intended to:
  • Remember prior project decisions and rules
  • Execute workflows automatically
  • Enforce safeguards (e.g., prevent deleting output files)

---

The 4 extension layers (mental model + responsibilities)

The speaker frames a mental model: choose which “layer” to use depending on whether something must always run, can be probabilistic/LLM-selected, or needs isolation.

1) claw.md (project memory / “house rules”) — deterministic-ish

• Acts as persistent project guidance loaded into the context for the project.
• Always present, with no explicit trigger required.
• Stores the project map/blueprint and critical instructions so Claude doesn’t need to relearn the project each time.

Important caveat: it’s described as deterministic but not always perfectly followed, especially if the file becomes too large or bloated (context limits may cause some instructions to be skipped).

What to include (to avoid bloating context window)

• Map: what the project is, what it teaches, where things live
• Intent / guardrails: “why” rules exist and what should never be touched without permission
• Playbook / patterns: preferred workflow patterns (e.g., limited external tool calls, query structure, test/deploy flow)

Progressive disclosure approach (best practice)

• Keep claw.md concise by referencing deeper docs instead of cramming everything into it.
• Example: use pointers to files like architecture.md, testing.md, deployment.md, rather than huge inline instructions.

Memory layers beyond claw.md

The speaker describes three levels of memory:

1. Project memory: claw.md in the project (e.g., ./.cloud/claw.md)
2. User-level memory: claw.md in the user home directory applies across projects
3. Auto-memory: memory.mmd (managed by Claude Code), meant to be concise; can be updated if needed

---

2) Skills — reusable modular workflows — probabilistic

Skills are repeatable routines defined by YAML-like configs. They can be:

• User-invocable via slash commands (manual control)
• Auto-invocable when Claude decides it’s relevant (LLM chooses execution based on context)

Two example skills created in the demo

• quick audit (user-invocable): checks drafts against brand voice structure and rules
• brand voice check (auto-invocable): automatically flags issues (e.g., forbidden phrases, weak openings, long paragraphs) when Claude writes/edits markdown in certain directories like drafts or output

Skill creator tooling

• Uses a “Skill Creator” plugin/command from a marketplace to generate or improve skills from a prompt.

Observed benefit in the demo

• Instead of multi-step copy/paste workflows (taking multiple prompts), a skill can run an entire quality audit with one command.
• Auto-invocable skills enforce quality automatically.

---

3) Hooks — guardrails that must run — deterministic

Hooks act as rules/sensors that guard the system against operations Claude Code would otherwise perform.

• Structured as: event + matcher + script
  • Event: when the hook evaluates (e.g., pre-tool use, post tool use, etc.)
  • Matcher: which tools/operations trigger it (e.g., bash commands)
  • Script: what to do (block, warn, validate, etc.)

Hook behavior based on outcome

• If the hook exits successfully, Claude continues.
• If dangerous action is detected, it blocks the operation.
• Warnings may allow continuation but record the issue.

Hook types mentioned

• Command hooks (shell scripts) — most common
• HTTP hooks (call a URL endpoint)
• Prompt hooks (evaluate via prompt, possibly delegating to an agent)

Demo hook created

A script file (e.g., block dangerous actions.sh) is configured to block risky shell actions such as:

• rm -rf
• get push force
• get reset, get clean
• drop table, drop database
• (etc.)

Configuration details:

• Enabled through settings.json under the project’s .cloud folder.
• Triggered on a pre-tool use event for bash.

Result shown:

• Attempts to delete from protected directories (e.g., output and draft) get blocked unless explicitly approved via targeted delete.

---

4) Agents / sub-agents — autonomous specialists — probabilistic but isolated

Agents (called Claude Code sub-agents) run in their own isolated context window:

• They don’t pollute the main session context.
• They can work in parallel, then return results to the main session.
• An orchestrator agent can delegate to other agents (concept briefly mentioned).

Agents are described as probabilistic by default (Claude decides to invoke them unless you explicitly direct Claude to run a named agent).

The speaker notes that deep dives on agents come later in the course.

---

Practical setup & command workflow (tutorial steps)

Using the interactive Claude Code terminal

• Demonstrated opening Claude Code by typing claud in an integrated terminal and working inside a project environment.

Slash commands / helpful UI commands

• /help opens shortcuts and command lists.
• Commands mentioned include:
  • ! to run bash commands directly
  • Add (+) for tagging or including file paths in prompts
  • A branch/clear-history-like command (used to clear conversation history to free context)
  • init for initializing extension files

Creating claw.md using init

• Run init to scan the project and generate claw.md.
• The created file includes purpose, commands, architecture, configuration, output structure, and key patterns.
• Best practice: store it under .cloud/ (e.g., ./.cloud/claw.md), though parent directory placement also works.

Plan mode vs accept edits mode

• The speaker mentions toggling modes (plan vs edit/execute) and shows executing commands from the UI.

---

Decision framework (how to choose the right layer)

Rule-of-thumb mapping:

• If something must run always and is about project context → use claw.md
• If it must run as a guardrail that Claude cannot bypass → use hooks
• If it should execute routinely within main context but as an auto/manual workflow → use skills
• If it needs its own context window and parallel specialist execution → use agents

---

Main speakers / sources

• Main speaker/source: the tutorial author/host (single instructor voice) presenting “How to Use CLAUDE.md, Skills & Hooks in Claude Code | Full Course Tutorial.”
• Primary software: Claude Code and its features (claw.md, skills, hooks, agents), including config files like settings.json, .cloud/ directory, and memory files (memory.mmd).