Every Level of Claude Code Explained in 39 Minutes

High-level summary

This is a practical 7-level walkthrough demonstrating how to use Claude Code (local CLI + IDE for Claude) to move from basic prompting to fully autonomous, integrated pipelines. The presenter tested the tool extensively, studied the creator’s notes, and tried community tutorials and workflows. The running example is a social‑media content creation system (generate posts from an Airtable calendar, apply brand voice, save outputs).

Levels, concepts and how to use them

1) Planning before execution (Plan mode)

• Use Plan mode (read‑only) to research the repo and produce a detailed plan before making edits.
• Plan mode triggers Claude’s “ask user questions” tool to gather assumptions and specifics so execution is reliable.
• After planning, switch to auto‑accept edits for one‑shot execution once the plan is settled.

2) Project rules and claude.md (project onboarding)

• Create a concise claude.md (project manifest / team onboarding) that states:
  • One‑line purpose
  • Exact steps
  • Where details live (link to brand voice docs)
  • Rules/non‑negotiables, edge cases, and working conventions
• Keep it short (readable in ~60s, ~20–30 instructions); reference detailed files instead of dumping long docs into claude.md.
• You can run /init to auto‑generate a claude.md from the repo; Claude reads this file at session start.

3) Slash commands, skills, hooks (reusable building blocks)

• Slash commands:
  • Saved prompts (files under .claude/commands) you manually invoke with arguments (e.g., /linkedin-post "topic").
  • Produce outputs and save them to output folders.
• Skills:
  • Richer context bundles (folders under .claude/skills with a skill.md) that Claude loads automatically when relevant or which you can explicitly call.
  • Include templates, examples, style guides (e.g., a humanizer skill to remove AI hallmarks).
• Hooks:
  • Programmatic, deterministic checks/triggers in settings.json (e.g., ban‑word checks, length checks, auto‑format).
  • Hooks run automatically and don’t consume LLM thinking tokens.
• Typical file layout examples:
  • .claude/commands/<command>.md
  • .claude/skills/<skill>/skill.md
  • settings.json for hooks
  • outputs/ and drafts/ folders for generated content

4) Integrations via MCP servers (Model Context Protocol)

• MCP servers bridge Claude Code to external apps (Airtable, Notion, etc.).
• Add MCP config (mcp.json) and API tokens or run built‑in /mcp commands to set up.
• Once connected, Claude can read/write records (pull ideas, create drafts, update status) so workflows live inside your apps rather than via copy/paste.
• Demonstrated Airtable flow: read bases/tables, pull a record, run a slash command to generate post variations, and write results back into the table.

5) GSD planning framework (structured project planning + UAT)

• GSD breaks large projects into phases, waves, and tasks, with explicit state, plans, and UAT (acceptance tests).
• Keeps context in discrete files (dot planning folder, state files, per‑phase plan & UAT docs) to avoid context rot and to let Claude plan and verify phases automatically.
• Best for larger, poorly scoped projects that need decomposition and verification.

6) Sub‑agents (agent teams, parallelism, context isolation)

• Sub‑agents are specialized personas (files under .claude/agents) with isolated context. Use them to:
  • Reduce context rot by isolating heavy context
  • Specialize tasks (researcher, writer, reviewer)
  • Run parallel work across multiple terminal instances for speed/throughput
• Modes:
  • Sequential collaboration: one agent calls another
  • Parallel independent agents across terminals
• Tip: “dangerously skip permissions” lets agents act without repeated permission prompts (accepts liability — use with caution).

7) Fully autonomous loops (Ralph loop / executor + PRD/acceptance criteria)

• Ralph loop: a bash‑driven executor that runs until tasks meet explicit completion criteria (max iterations + done condition) defined in a PRD.json (product requirements with UAT / acceptance criteria).
• Ideal for well‑scoped tasks (e.g., “write six LinkedIn posts under 200 words with no banned words”): Ralph executes, verifies via UAT, marks done, and moves to the next task while feeding fresh context windows to avoid context rot.
• Use /plugin install ralph (or similar) and run /ralph-loop with safeguards (max iterations) to automate end‑to‑end pipelines.

Best practice: always include explicit acceptance criteria and a max‑iteration limit when running autonomous loops.

Operational best practices & troubleshooting

• File and folder conventions matter: .claude/commands, .claude/skills, .claude/agents, settings.json, mcp.json, prd.json.
• Keep claude.md minimal; reference richer docs for brand voice, examples, and edge cases.
• Use skills to avoid bloating the main context; install community skills from GitHub repos and adapt them.
• Use hooks for deterministic checks cheaply (no LLM thinking cost).
• Watch context window / “context rot”: use file‑based context, sub‑agents, skills, and Ralph loops to limit token blowup.
• Safety and cost controls: set max iterations on Ralph, and be cautious with “skip permissions”.

Demo use cases shown

• Social media content machine:
  • Plan → use slash commands and brand‑voice skill → humanizer skill → hooks for banned words → integrate with Airtable via MCP to read ideas and write back drafts → run GSD for larger planning → run sub‑agents in parallel → run Ralph loop to produce weekly batch autonomously.
• Community skills demonstrated (examples):
  • Humanizer
  • Front‑end design helper
  • SEO reviewer
  • Email drafter
  • Generative image tools

Commands and quick references mentioned

• /init — create claude.md from repo
• Plan mode (Shift+Tab toggle)
• /mcp — configure MCP integrations (Airtable example)
• settings.json — hooks configuration (ban words, length)
• .claude/commands and .claude/skills — command and skill files
• /plugin install ralph and /ralph-loop — Ralph executor
• PRD.json (prd.json) — product requirements + acceptance criteria for automated loops

Resources, guides and tutorials referenced

• Creator’s (Boris) post and team practices (shared claude.md; versioned on Git)
• Community skill/agent repos on GitHub (skill marketplace / skills MP)
• Masterclass / “masterclaw” tutorials and other community tutorials
• Reddit thread summarizing sub‑agent benefits (posts by “Sax Appeal” and “Kite”)

Main speakers / sources

• Video presenter (author of the walkthrough; tested 150+ hours of Claude Code workflows)
• Boris (creator of Claude Code) — referenced for best practices (Plan mode, claude.md, running multiple instances)
• Community sources: GitHub skill repos (including the humanizer skill), Reddit posts, and community tutorials/masterclasses mentioned in the video

Appendix: extras available

Templates and quick checklists used in the demo include:

• claude.md template (project manifest / onboarding)
• Command and skill file templates (.claude/commands/*.md, .claude/skills/*/skill.md)
• settings.json hooks examples (ban words, length checks)
• mcp.json example for Airtable
• prd.json example with UAT/acceptance criteria

(These can be converted into a quick checklist or into actual template files if needed.)