← Back to all projects

CLAUDE CODE ADVANCED PROJECTS

Advanced Claude Code CLI Mastery: 20 Projects

Learning Goal: Master advanced Claude Code CLI techniques through hands-on projects that produce real, functional outcomes.

---

Core Concept Analysis

To truly understand Claude Code as a platform (not just an app), you need to master these fundamental building blocks:

Concept Area	What You’ll Learn
Hooks System	Lifecycle events, deterministic automation, input/output transformation
Skills Development	Model-invoked capabilities, SKILL.md architecture, tool restrictions
MCP Servers	External tool integration, resource exposure, custom protocols
Headless Mode	CI/CD automation, programmatic control, JSON output processing
Subagents	Specialized AI agents, delegation patterns, context isolation
System Prompts	Behavioral customization, append vs replace strategies
Permission System	allow/deny/ask rules, security policies, enterprise controls
Session Management	Continuity, worktrees, naming, forking sessions

---

Project 1: Pre-Commit Hook Guardian

• File: PROJECT_01_PRECOMMIT_HOOK_GUARDIAN.md
• Main Programming Language: Bash/Shell
• Alternative Programming Languages: Python, Node.js, Go
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Hooks / Git Integration / Automation
• Software or Tool: Claude Code Hooks, Git
• Main Book: “Effective Shell” by Dave Kerr

What you’ll build: A PreToolUse hook that intercepts all Bash(git commit:*) commands, runs linting/tests before allowing commits, and blocks commits with failing tests while providing Claude with detailed failure context.

Why it teaches Claude Code hooks: This forces you to understand the hook lifecycle, JSON input/output formats, exit codes (0 for success, 2 for blocking errors), and how to inject context back into Claude’s decision-making process.

Core challenges you’ll face:

• Hook JSON parsing (extracting tool_input from stdin) → maps to hook input structure
• Conditional blocking (exit 2 vs exit 0) → maps to hook exit code semantics
• Context injection (stderr becomes Claude’s feedback) → maps to hook output patterns
• Matcher configuration (targeting specific Bash patterns) → maps to hook matching rules

Key Concepts:

• Hook Events: “Claude Code Hooks Documentation” - https://code.claude.com/docs/en/hooks.md
• JSON Processing in Bash: “Effective Shell” Chapter 18 - Dave Kerr
• Git Hooks: “Pro Git” Chapter 8.3 - Scott Chacon

Difficulty: Intermediate Time estimate: Weekend Prerequisites: Basic bash scripting, Git fundamentals, JSON parsing with jq

Real world outcome:

# When you try to commit code with failing tests:
$ claude
> commit my changes

[HOOK] Running pre-commit checks...
[HOOK] ❌ Tests failed: 3 failures in auth.test.js
[HOOK] Blocking commit until tests pass

Claude: I see the pre-commit hook blocked the commit because there are 3
failing tests in auth.test.js. Let me fix those first...

Learning milestones:

1. Hook fires on git commit → You understand hook matchers
2. Tests run and block on failure → You understand exit codes
3. Claude receives failure context → You understand stderr injection
4. Hook allows successful commits → You’ve mastered the full lifecycle

---

Project 2: Auto-Formatting PostToolUse Hook

• File: PROJECT_02_AUTO_FORMAT_HOOK.md
• Main Programming Language: Bash/Shell
• Alternative Programming Languages: Python, Node.js
• Coolness Level: Level 2: Practical but Forgettable
• Business Potential: 2. The “Micro-SaaS / Pro Tool”
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Hooks / Code Quality / Automation
• Software or Tool: Claude Code Hooks, Prettier, ESLint, Black
• Main Book: “Effective Shell” by Dave Kerr

What you’ll build: A PostToolUse hook that automatically runs formatters (Prettier, Black, gofmt) after every Edit or Write operation, ensuring all code Claude produces is perfectly formatted without manual intervention.

Why it teaches PostToolUse hooks: You’ll learn how to react to completed tool operations, extract file paths from tool outputs, determine file types, and run appropriate formatters—all transparently to Claude.

Core challenges you’ll face:

• Tool output parsing (extracting modified file paths) → maps to PostToolUse input structure
• File type detection (matching formatters to extensions) → maps to conditional logic
• Silent operation (format without interrupting Claude) → maps to non-blocking hooks
• Error handling (formatter failures shouldn’t crash) → maps to robust hook design

Key Concepts:

• PostToolUse Events: “Claude Code Hooks Documentation” - https://code.claude.com/docs/en/hooks.md
• Shell Scripting: “Wicked Cool Shell Scripts” Chapter 5 - Dave Taylor
• Code Formatting: Prettier/Black documentation

Difficulty: Intermediate Time estimate: 1-2 days Prerequisites: Shell scripting, understanding of code formatters

Real world outcome:

# After Claude edits a file:
$ claude
> add a new function to utils.js

[Claude writes messy code]
[HOOK] Auto-formatting utils.js with Prettier...
[HOOK] ✓ Formatted successfully

# The file on disk is now perfectly formatted
$ cat utils.js  # Shows clean, formatted code

Learning milestones:

1. Hook triggers after Edit/Write → You understand PostToolUse timing
2. Correct formatter runs per file type → You understand conditional logic in hooks
3. Multiple files formatted in sequence → You understand hook scalability
4. Claude is unaware of formatting → You’ve achieved transparent automation

---

Project 3: Custom Skill - Database Query Analyzer

• File: PROJECT_03_DATABASE_SKILL.md
• Main Programming Language: Markdown (SKILL.md) + Python/SQL
• Alternative Programming Languages: Node.js, Go
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Skills / Database / Query Optimization
• Software or Tool: Claude Code Skills, PostgreSQL/MySQL
• Main Book: “Designing Data-Intensive Applications” by Martin Kleppmann

What you’ll build: A complete skill in ~/.claude/skills/db-analyzer/ that Claude automatically invokes when you mention “query performance”, “slow query”, or “EXPLAIN”. It includes reference documentation, helper scripts, and restricted tools (Read, Grep, Bash for psql only).

Why it teaches Skills development: You’ll understand the full skill architecture—SKILL.md frontmatter, description triggers, tool restrictions, supporting files, and how Claude discovers and activates skills based on conversation context.

Core challenges you’ll face:

• Trigger word optimization (getting Claude to discover your skill) → maps to description engineering
• Tool restrictions (limiting to safe database operations) → maps to allowed-tools
• Multi-file organization (SKILL.md + references + scripts) → maps to skill architecture
• Context efficiency (progressive loading of references) → maps to skill design patterns

Key Concepts:

• Skill Architecture: “Claude Code Skills Documentation” - https://code.claude.com/docs/en/skills.md
• Query Optimization: “Designing Data-Intensive Applications” Chapter 3 - Martin Kleppmann
• PostgreSQL EXPLAIN: PostgreSQL Documentation

Difficulty: Intermediate Time estimate: Weekend Prerequisites: SQL knowledge, understanding of query execution plans

Real world outcome:

$ claude
> This query is running slow, can you help?

[Claude automatically activates db-analyzer skill]

Claude: I'm using the database analyzer skill. Let me run EXPLAIN ANALYZE
on your query...

[Runs: psql -c "EXPLAIN ANALYZE SELECT..."]

Based on the execution plan, I see a sequential scan on the users table.
Here's my optimization recommendation...

Learning milestones:

1. Skill activates on trigger words → You understand description engineering
2. Only allowed tools are available → You understand tool restrictions
3. Helper scripts execute correctly → You understand supporting files
4. Reference docs load on demand → You’ve mastered progressive loading

---

Project 4: MCP Server - Local File Watcher

• File: PROJECT_04_MCP_FILE_WATCHER.md
• Main Programming Language: TypeScript/Node.js
• Alternative Programming Languages: Python, Go, Rust
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 4. The “Open Core” Infrastructure
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: MCP Protocol / Real-time Systems / IPC
• Software or Tool: MCP SDK, Node.js, File System Events
• Main Book: “Node.js Design Patterns” by Mario Casciaro

What you’ll build: A custom MCP server that exposes file watching capabilities—Claude can subscribe to file changes, get notified of modifications, and query recent change history. This teaches you the MCP protocol from the ground up.

Why it teaches MCP development: Building an MCP server forces you to understand the protocol, tool definitions, resource exposure, transport mechanisms (stdio/HTTP), and how Claude discovers and invokes MCP tools.

Core challenges you’ll face:

• MCP protocol implementation (tool definitions, responses) → maps to MCP architecture
• Stdio transport (JSON-RPC over stdin/stdout) → maps to MCP transports
• Resource exposure (exposing watched files as @-mentionable) → maps to MCP resources
• State management (tracking subscriptions across calls) → maps to stateful MCP servers

Key Concepts:

• MCP Protocol: “Model Context Protocol Documentation” - https://modelcontextprotocol.io
• MCP in Claude Code: “Claude Code MCP Guide” - https://code.claude.com/docs/en/mcp.md
• Node.js Streams: “Node.js Design Patterns” Chapter 5 - Mario Casciaro

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: TypeScript/Node.js, understanding of JSON-RPC, file system events

Real world outcome:

# Configure your MCP server
$ claude mcp add file-watcher -- node ./my-mcp-server/index.js

$ claude
> Watch the src/ directory for changes

[Claude invokes mcp__file-watcher__subscribe]

Claude: I'm now watching src/ for changes. I'll let you know when files change.

# You edit a file in another terminal
[MCP notifies Claude]

Claude: I detected that src/utils.js was modified. Would you like me to
review the changes?

Learning milestones:

1. Server connects via stdio → You understand MCP transports
2. Tools appear in Claude’s toolset → You understand tool discovery
3. Resources are @-mentionable → You understand MCP resources
4. Real-time notifications work → You’ve mastered stateful MCP

---

Project 5: Headless CI/CD PR Reviewer

• File: PROJECT_05_HEADLESS_PR_REVIEWER.md
• Main Programming Language: Bash + YAML (GitHub Actions)
• Alternative Programming Languages: Python, Node.js
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: CI/CD / Automation / Code Review
• Software or Tool: Claude Code Headless, GitHub Actions
• Main Book: “Continuous Delivery” by Jez Humble

What you’ll build: A GitHub Action that runs Claude Code in headless mode (claude -p) to automatically review PRs, post comments with findings, and optionally block merges if critical issues are found.

Why it teaches headless mode: You’ll master non-interactive Claude Code—output formats (--output-format json), tool restrictions (--allowedTools), session continuity (--resume), and integrating Claude into automated pipelines.

Core challenges you’ll face:

• Non-interactive execution (no prompts, deterministic) → maps to headless mode flags
• Output parsing (extracting findings from JSON) → maps to output format handling
• Tool restriction (read-only for safety) → maps to –allowedTools patterns
• GitHub API integration (posting comments) → maps to pipeline integration

Key Concepts:

• Headless Mode: “Claude Code Headless Documentation” - https://code.claude.com/docs/en/headless.md
• GitHub Actions: GitHub Actions Documentation
• CI/CD Patterns: “Continuous Delivery” Chapter 5 - Jez Humble

Difficulty: Intermediate Time estimate: 3-5 days Prerequisites: GitHub Actions, bash scripting, understanding of CI/CD

Real world outcome:

# .github/workflows/claude-review.yml
- name: Claude PR Review
  run: |
    gh pr diff ${{ github.event.pull_request.number }} | \
    claude -p "Review this PR for bugs and security issues" \
      --output-format json \
      --allowedTools "Read,Grep,Glob" | \
    jq -r '.response' | \
    gh pr comment ${{ github.event.pull_request.number }} --body-file -

# On every PR, a comment appears:
Claude Code Review:
- ⚠️ Potential SQL injection in line 45 of api/users.js
- 💡 Consider adding input validation in auth.js
- ✅ Test coverage looks good

Learning milestones:

1. Claude runs in CI without prompts → You understand -p mode
2. JSON output is parseable → You understand --output-format
3. Only safe tools are available → You understand --allowedTools
4. Comments post automatically → You’ve achieved full CI integration

---

Project 6: Custom Subagent - Security Auditor

• File: PROJECT_06_SECURITY_SUBAGENT.md
• Main Programming Language: JSON + Markdown
• Alternative Programming Languages: N/A (configuration-based)
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Subagents / Security / Code Analysis
• Software or Tool: Claude Code Subagents
• Main Book: “Practical Binary Analysis” by Dennis Andriesse

What you’ll build: A custom subagent in .claude/agents/security-auditor.json that specializes in security analysis—restricted to read-only tools, with a security-focused system prompt, and automatic delegation when security topics arise.

Why it teaches subagents: You’ll understand agent definitions (prompt, tools, model selection), automatic vs explicit delegation, tool isolation between agents, and how the main agent orchestrates subagents.

Core challenges you’ll face:

• Agent definition (JSON schema for agents) → maps to subagent configuration
• Tool isolation (limiting to safe operations) → maps to agent tool restrictions
• Delegation triggers (when Claude uses your agent) → maps to agent descriptions
• Context handoff (what information passes between agents) → maps to agent communication

Key Concepts:

• Subagent Architecture: “Claude Code Subagents” - https://code.claude.com/docs/en/subagents.md
• Security Analysis: “Practical Binary Analysis” Chapter 1 - Dennis Andriesse
• OWASP Guidelines: OWASP Top 10 Documentation

Difficulty: Intermediate Time estimate: 2-3 days Prerequisites: Understanding of security concepts, JSON configuration

Real world outcome:

$ claude
> I just added authentication to the app, can you check it for security issues?

[Main Claude automatically delegates to security-auditor]

Claude (security-auditor): I'm analyzing your authentication implementation
for security vulnerabilities...

[Uses only Read, Grep, Glob - cannot modify files]

Findings:
1. 🔴 CRITICAL: Password stored in plain text in user.js:45
2. 🟡 MEDIUM: Missing rate limiting on login endpoint
3. 🟢 GOOD: HTTPS enforced correctly

Recommendations...

Learning milestones:

1. Agent appears in /agents list → You understand agent registration
2. Delegation happens automatically → You understand description triggers
3. Agent can only read, not write → You understand tool isolation
4. Main agent receives findings → You’ve mastered agent communication

---

Project 7: Session Manager CLI Wrapper

• File: PROJECT_07_SESSION_MANAGER.md
• Main Programming Language: Bash/Zsh
• Alternative Programming Languages: Python, Go, Rust
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 2. The “Micro-SaaS / Pro Tool”
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Session Management / CLI Design / Productivity
• Software or Tool: Claude Code Sessions, fzf
• Main Book: “Effective Shell” by Dave Kerr

What you’ll build: A wrapper script (cc) that enhances Claude Code session management—fuzzy session search with fzf, automatic naming based on git branch, session notes, and quick resume shortcuts.

Why it teaches session management: You’ll deeply understand session IDs, the --resume and --continue flags, session naming with /rename, session forking with --fork-session, and how to build productivity tools around Claude’s session system.

Core challenges you’ll face:

• Session discovery (finding and parsing session data) → maps to session storage
• Fuzzy search integration (fzf for selection) → maps to CLI UX
• Branch-based naming (auto-name from git) → maps to session naming conventions
• Session notes (storing metadata) → maps to session augmentation

Key Concepts:

• Session Management: “Claude Code Common Workflows” - https://code.claude.com/docs/en/common-workflows.md
• CLI Design: “Effective Shell” Chapter 15 - Dave Kerr
• fzf Integration: fzf documentation

Difficulty: Intermediate Time estimate: Weekend Prerequisites: Bash scripting, fzf familiarity

Real world outcome:

# Quick resume with fuzzy search
$ cc resume
> auth-refactor (feature/auth) - 2 hours ago
  api-migration (main) - yesterday
  bug-fix-123 (fix/login) - 3 days ago
[Use arrows to select, Enter to resume]

# Auto-named sessions based on branch
$ cc start
Creating session: feature/new-dashboard (auto-named from branch)

# View session notes
$ cc notes auth-refactor
Session: auth-refactor
Created: 2024-01-15 10:30
Branch: feature/auth
Notes: Working on JWT implementation, stuck on refresh tokens

Learning milestones:

1. Sessions list and filter correctly → You understand session discovery
2. Fuzzy search works smoothly → You understand CLI UX integration
3. Auto-naming from git branch → You understand naming conventions
4. Notes persist between sessions → You’ve built session augmentation

---

Project 8: Permission Policy Engine

• File: PROJECT_08_PERMISSION_ENGINE.md
• Main Programming Language: JSON + Bash
• Alternative Programming Languages: Python, Node.js
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Permissions / Security / Policy Management
• Software or Tool: Claude Code Permissions System
• Main Book: “Security in Computing” by Charles Pfleeger

What you’ll build: A comprehensive permission policy system with multiple profiles (development, staging, production), automatic profile switching based on git branch, and detailed audit logging of all permission decisions.

Why it teaches the permission system: You’ll master allow/deny/ask rules, gitignore-style patterns, prefix matching for Bash commands, domain-based WebFetch rules, and the scope hierarchy (enterprise → project → user → local).

Core challenges you’ll face:

• Rule syntax mastery (patterns for each tool type) → maps to permission rule formats
• Scope precedence (which settings win) → maps to configuration hierarchy
• Profile switching (branch-based policies) → maps to dynamic configuration
• Audit logging (tracking all decisions) → maps to PermissionRequest hooks

Key Concepts:

• Permission System: “Claude Code IAM Documentation” - https://code.claude.com/docs/en/iam.md
• Security Policies: “Security in Computing” Chapter 4 - Charles Pfleeger
• Configuration Management: “Effective Shell” - Dave Kerr

Difficulty: Advanced Time estimate: 1 week Prerequisites: Understanding of permission systems, security concepts

Real world outcome:

# Automatic policy switching
$ git checkout production
[POLICY] Switching to production profile: read-only mode

$ claude
> delete the old user records

Claude: I'm in read-only mode for the production branch. I cannot execute
destructive operations. Would you like to switch to a development branch?

# Audit log
$ cat ~/.claude/audit.log
2024-01-15 10:30:45 DENY Bash(rm -rf ./data) branch=production rule=no-destructive
2024-01-15 10:31:02 ALLOW Read(./src/app.js) branch=production rule=allow-src

Learning milestones:

1. Policies load based on context → You understand configuration scopes
2. Rules correctly allow/deny/ask → You understand rule syntax
3. Branch switching changes policies → You understand dynamic policies
4. All decisions are logged → You’ve achieved audit compliance

---

Project 9: UserPromptSubmit Prompt Enhancer

• File: PROJECT_09_PROMPT_ENHANCER.md
• Main Programming Language: Python or Node.js
• Alternative Programming Languages: Bash, Go
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Hooks / NLP / Context Enrichment
• Software or Tool: Claude Code Hooks, LLM-based classification
• Main Book: “Natural Language Processing with Python” by Steven Bird

What you’ll build: A UserPromptSubmit hook that intercepts your prompts, analyzes intent using a fast local model (or Haiku via prompt hook), and enriches the prompt with relevant context, file references, and suggested approaches before Claude sees it.

Why it teaches UserPromptSubmit hooks: This is the most powerful hook—you can transform, enrich, or even block prompts before Claude processes them. You’ll understand prompt interception, context injection, and using hooks for intelligent preprocessing.

Core challenges you’ll face:

• Prompt interception (accessing user input before Claude) → maps to UserPromptSubmit hook
• Intent classification (understanding what user wants) → maps to NLP techniques
• Context enrichment (adding relevant files/docs) → maps to hookSpecificOutput.updatedPrompt
• Performance (enrichment must be fast) → maps to efficient hook design

Key Concepts:

• UserPromptSubmit Hook: “Claude Code Hooks Guide” - https://code.claude.com/docs/en/hooks-guide.md
• Prompt Engineering: Anthropic Prompt Engineering Guide
• NLP Basics: “Natural Language Processing with Python” Chapter 1 - Steven Bird

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: NLP basics, understanding of prompt engineering

Real world outcome:

$ claude
> fix the login bug

[UserPromptSubmit hook intercepts]
[Analyzes: intent=bug_fix, area=authentication]
[Enriches with: @src/auth/login.js, @logs/error.log, recent commits]

# Claude actually receives:
"fix the login bug

Context added by prompt enhancer:
- Relevant file: @src/auth/login.js (modified 2 hours ago)
- Recent error: 'TypeError: Cannot read property token of undefined'
- Related commit: abc123 'refactored auth flow'"

Claude: I see the login bug is related to the token handling in line 45...

Learning milestones:

1. Hook intercepts all prompts → You understand UserPromptSubmit
2. Intent classification works → You understand NLP integration
3. Context is correctly injected → You understand prompt enrichment
4. Claude receives enhanced prompts → You’ve achieved intelligent preprocessing

---

Project 10: Multi-Worktree Orchestrator

• File: PROJECT_10_WORKTREE_ORCHESTRATOR.md
• Main Programming Language: Bash/Zsh
• Alternative Programming Languages: Python, Go
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 2. The “Micro-SaaS / Pro Tool”
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Git Worktrees / Parallel Development / Process Management
• Software or Tool: Git Worktrees, tmux/screen, Claude Code
• Main Book: “Pro Git” by Scott Chacon

What you’ll build: A tool that manages multiple git worktrees with separate Claude Code instances—spawn parallel development sessions, synchronize findings between them, and orchestrate multi-feature development with isolated contexts.

Why it teaches parallel Claude workflows: You’ll master git worktrees for parallel file states, running multiple Claude instances, session isolation, and orchestrating AI-assisted development across multiple features simultaneously.

Core challenges you’ll face:

• Worktree management (create, switch, clean up) → maps to git worktree operations
• Claude instance isolation (separate sessions per worktree) → maps to session management
• Cross-session communication (sharing findings) → maps to orchestration patterns
• Resource management (don’t spawn too many instances) → maps to process management

Key Concepts:

• Git Worktrees: “Pro Git” Chapter 7.5 - Scott Chacon
• Parallel Workflows: “Claude Code Best Practices” - Anthropic Engineering Blog
• Process Management: “Effective Shell” - Dave Kerr

Difficulty: Advanced Time estimate: 1 week Prerequisites: Git worktrees, tmux/screen, shell scripting

Real world outcome:

# Spawn 3 parallel development sessions
$ worktree-claude spawn feature-auth feature-api feature-ui

[Creates 3 worktrees in ../project-feature-*]
[Opens tmux with 3 panes, each running Claude]

# In pane 1 (feature-auth):
Claude: Working on authentication...

# In pane 2 (feature-api):
Claude: Building API endpoints...

# In pane 3 (feature-ui):
Claude: Creating UI components...

# Synchronize findings
$ worktree-claude sync
[Collects summaries from all 3 sessions]
[Creates integration-notes.md with cross-feature considerations]

Learning milestones:

1. Worktrees create successfully → You understand git worktree operations
2. Each Claude has isolated context → You understand session isolation
3. Parallel work doesn’t interfere → You understand context separation
4. Findings synchronize correctly → You’ve mastered orchestration

---

Project 11: Custom Output Style System

• File: PROJECT_11_OUTPUT_STYLES.md
• Main Programming Language: Markdown + JSON
• Alternative Programming Languages: N/A (configuration-based)
• Coolness Level: Level 2: Practical but Forgettable
• Business Potential: 2. The “Micro-SaaS / Pro Tool”
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: System Prompts / Behavioral Customization
• Software or Tool: Claude Code Output Styles
• Main Book: “The Pragmatic Programmer” by David Thomas

What you’ll build: A collection of custom output styles for different contexts—”Code Reviewer” (terse, critical), “Teacher” (explanatory, patient), “Pair Programmer” (collaborative, questioning), switchable with /output-style.

Why it teaches system prompt customization: You’ll understand how output styles modify Claude’s behavior, the difference between --system-prompt (replace) and --append-system-prompt (add), and how to create context-appropriate AI personas.

Core challenges you’ll face:

• Behavioral specification (defining distinct personas) → maps to prompt engineering
• Style switching (quick context changes) → maps to output style configuration
• Persona consistency (maintaining character) → maps to prompt robustness
• Context appropriateness (right style for the task) → maps to workflow integration

Key Concepts:

• Output Styles: “Claude Code Settings” - https://code.claude.com/docs/en/settings.md
• Prompt Engineering: Anthropic Prompt Engineering Guide
• Communication Styles: “The Pragmatic Programmer” Chapter 1 - David Thomas

Difficulty: Intermediate Time estimate: 2-3 days Prerequisites: Understanding of prompt engineering

Real world outcome:

$ claude
> /output-style code-reviewer

Claude (Code Reviewer mode): Understood. I'll be direct and critical.

> review this function

Claude: Issues:
1. Line 15: Magic number. Extract to constant.
2. Line 23: No error handling. Will crash on null input.
3. Line 30: O(n²) complexity. Use a Map instead.
Rating: 4/10. Needs significant refactoring.

> /output-style teacher

Claude (Teacher mode): Of course! I'd be happy to explain this in detail...

Learning milestones:

1. Styles switch correctly → You understand output style configuration
2. Behavior changes noticeably → You understand prompt impact
3. Personas remain consistent → You understand prompt robustness
4. Styles fit different workflows → You’ve achieved context-appropriate AI

---

Project 12: MCP Resource Browser

• File: PROJECT_12_MCP_RESOURCE_BROWSER.md
• Main Programming Language: TypeScript/Node.js
• Alternative Programming Languages: Python, Go
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 4. The “Open Core” Infrastructure
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: MCP Protocol / Resource Management / CLI Tools
• Software or Tool: MCP SDK, Node.js
• Main Book: “Node.js Design Patterns” by Mario Casciaro

What you’ll build: An MCP server that exposes your project’s documentation, issue tracker, and API specs as @-mentionable resources—Claude can reference @docs:api/users, @issues:123, or @schema:database directly in conversation.

Why it teaches MCP resources: While Project 4 focuses on tools, this project focuses on resources—the data/content that MCP servers expose. You’ll understand resource URIs, content types, and how resources become part of Claude’s context.

Core challenges you’ll face:

• Resource definition (URIs, types, descriptions) → maps to MCP resource schema
• Content delivery (returning formatted content) → maps to resource handlers
• Discovery (making resources findable) → maps to resource listing
• Integration (@ mentions working smoothly) → maps to resource consumption

Key Concepts:

• MCP Resources: “MCP Protocol Documentation” - https://modelcontextprotocol.io/docs/concepts/resources
• URI Design: RFC 3986
• Content Negotiation: HTTP Content-Type patterns

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: MCP basics (from Project 4), URI design, content formatting

Real world outcome:

$ claude
> Compare @docs:api/users with @schema:users_table

[Claude fetches both resources via MCP]

Claude: Comparing the API documentation with the database schema:

API (from docs:api/users):
- Endpoint: GET /users/:id
- Returns: { id, name, email, created_at }

Schema (from schema:users_table):
- Columns: id, name, email, created_at, password_hash, last_login

Discrepancy: The API doesn't expose password_hash and last_login
(correctly), but consider adding last_login to the API response...

Learning milestones:

1. Resources appear in @ autocomplete → You understand resource discovery
2. Content fetches correctly → You understand resource handlers
3. Multiple resource types work → You understand resource variety
4. Claude reasons across resources → You’ve achieved seamless integration

---

Project 13: Sandbox Escape Detector

• File: PROJECT_13_SANDBOX_DETECTOR.md
• Main Programming Language: Bash + Python
• Alternative Programming Languages: Go, Rust
• Coolness Level: Level 5: Pure Magic (Super Cool)
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 4: Expert (The Systems Architect)
• Knowledge Area: Security / Sandboxing / System Internals
• Software or Tool: Claude Code Sandbox, macOS/Linux Security
• Main Book: “Practical Binary Analysis” by Dennis Andriesse

What you’ll build: A security tool that monitors Claude Code’s sandbox, detects potential escape attempts, logs all network/filesystem access attempts outside the sandbox, and provides detailed security reports.

Why it teaches sandboxing: You’ll deeply understand Claude Code’s filesystem/network isolation, sandbox boundaries, the sandbox configuration options, excluded commands, and how to monitor/enforce security policies.

Core challenges you’ll face:

• Sandbox architecture (understanding isolation boundaries) → maps to sandbox internals
• Access monitoring (detecting boundary violations) → maps to security monitoring
• Policy enforcement (blocking unauthorized access) → maps to security policies
• Reporting (logging and alerting) → maps to security auditing

Key Concepts:

• Claude Code Sandbox: “Claude Code Sandbox Documentation” - https://code.claude.com/docs/en/sandbox.md
• OS Security: “Practical Binary Analysis” Chapter 9 - Dennis Andriesse
• Security Monitoring: “The Practice of Network Security Monitoring” - Richard Bejtlich

Difficulty: Expert Time estimate: 2-3 weeks Prerequisites: Understanding of OS security, sandboxing concepts, system calls

Real world outcome:

# Enable sandbox with monitoring
$ claude --sandbox

> execute curl https://external-api.com/data

[SANDBOX] Network access attempt blocked:
  Target: external-api.com:443
  Reason: Outside allowed network policy
  Action: BLOCKED

[SECURITY REPORT]
Session: abc123
Duration: 45 minutes
Blocked attempts: 3
  - Network: external-api.com (blocked)
  - Filesystem: /etc/passwd (blocked)
  - Filesystem: ~/.ssh/id_rsa (blocked)

Learning milestones:

1. Sandbox activates correctly → You understand sandbox configuration
2. Violations are detected → You understand security monitoring
3. Reports are comprehensive → You understand security auditing
4. System remains secure → You’ve achieved defense in depth

---

Project 14: Extended Thinking Analyzer

• File: PROJECT_14_THINKING_ANALYZER.md
• Main Programming Language: Python + JSON
• Alternative Programming Languages: Node.js, Go
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 1. The “Resume Gold”
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Extended Thinking / Reasoning / Analysis
• Software or Tool: Claude Code Extended Thinking
• Main Book: “Thinking, Fast and Slow” by Daniel Kahneman

What you’ll build: A tool that captures, parses, and analyzes Claude’s extended thinking output—visualizing reasoning chains, identifying decision points, and providing insights into how Claude approaches complex problems.

Why it teaches extended thinking: You’ll master the thinking mode toggle, MAX_THINKING_TOKENS configuration, thinking output capture (via Ctrl+O or JSON output), and understanding Claude’s internal reasoning process.

Core challenges you’ll face:

• Thinking capture (accessing extended thinking output) → maps to thinking mode configuration
• Chain parsing (structuring reasoning steps) → maps to output parsing
• Visualization (presenting reasoning clearly) → maps to data visualization
• Pattern analysis (identifying reasoning patterns) → maps to meta-cognition analysis

Key Concepts:

• Extended Thinking: “Claude Code Common Workflows” - https://code.claude.com/docs/en/common-workflows.md
• Reasoning Patterns: “Thinking, Fast and Slow” - Daniel Kahneman
• Visualization: D3.js or similar

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: JSON parsing, data visualization, understanding of reasoning

Real world outcome:

$ claude --output-format json "ultrathink: design a caching layer"

# Your analyzer processes the output:
$ thinking-analyzer analyze session-123.json

Reasoning Chain Analysis:
========================
1. Problem Understanding (tokens: 1,234)
   └─ Identified: high latency, frequent DB queries

2. Option Generation (tokens: 2,456)
   ├─ Option A: Redis (considered, scored 8/10)
   ├─ Option B: In-memory (considered, scored 6/10)
   └─ Option C: CDN (rejected, reason: not applicable)

3. Decision Point (token: 3,890)
   └─ Selected: Redis
   └─ Reasoning: "better for distributed systems"

4. Implementation Planning (tokens: 4,567)
   └─ 5 steps identified...

Key Insights:
- Spent 45% of thinking on option comparison
- Decision was primarily driven by scalability concerns
- Considered 3 alternatives before selecting

Learning milestones:

1. Thinking output captured → You understand thinking mode
2. Reasoning chains parsed → You understand output structure
3. Visualization works → You understand reasoning presentation
4. Patterns identified → You’ve achieved meta-cognitive analysis

---

Project 15: Plugin Development Kit

• File: PROJECT_15_PLUGIN_DEV_KIT.md
• Main Programming Language: TypeScript/Node.js
• Alternative Programming Languages: Python
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 5. The “Industry Disruptor”
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Plugins / Extension Architecture / Distribution
• Software or Tool: Claude Code Plugins
• Main Book: “Node.js Design Patterns” by Mario Casciaro

What you’ll build: A complete plugin that bundles skills, hooks, slash commands, subagents, and an MCP server—along with a development toolkit for creating, testing, and publishing Claude Code plugins.

Why it teaches plugin development: Plugins are the ultimate Claude Code extension mechanism. You’ll understand plugin structure, bundling multiple components, marketplace distribution, and creating shareable extensions for the community.

Core challenges you’ll face:

• Plugin architecture (bundling all component types) → maps to plugin structure
• Development workflow (create, test, iterate) → maps to plugin development
• Packaging (preparing for distribution) → maps to plugin bundling
• Publishing (marketplace submission) → maps to plugin distribution

Key Concepts:

• Plugin System: “Claude Code Plugins” - https://code.claude.com/docs/en/plugins.md
• Extension Architecture: “Node.js Design Patterns” Chapter 8 - Mario Casciaro
• Package Management: npm/yarn documentation

Difficulty: Advanced Time estimate: 2-3 weeks Prerequisites: Understanding of all previous component types, npm packaging

Real world outcome:

# Using your Plugin Dev Kit:
$ claude-plugin init my-awesome-plugin

Creating plugin structure:
  my-awesome-plugin/
  ├── plugin.json (manifest)
  ├── skills/
  │   └── my-skill/SKILL.md
  ├── hooks/
  │   └── pre-commit.sh
  ├── commands/
  │   └── my-command.md
  ├── agents/
  │   └── my-agent.json
  └── mcp/
      └── server.js

$ claude-plugin test
Running plugin tests...
✓ Skill activates correctly
✓ Hook executes on trigger
✓ Command available in Claude
✓ Agent delegates properly
✓ MCP server connects

$ claude-plugin publish
Publishing to Claude Code marketplace...
✓ Plugin published: my-awesome-plugin v1.0.0

Learning milestones:

1. Plugin structure created → You understand plugin architecture
2. All components work together → You understand bundling
3. Tests pass → You understand plugin quality
4. Plugin published → You’ve mastered distribution

---

Project 16: Context Window Monitor

• File: PROJECT_16_CONTEXT_MONITOR.md
• Main Programming Language: Bash + Python
• Alternative Programming Languages: Node.js, Go
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 2. The “Micro-SaaS / Pro Tool”
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Context Management / Token Optimization / UX
• Software or Tool: Claude Code Context Window
• Main Book: “Designing Data-Intensive Applications” by Martin Kleppmann

What you’ll build: A real-time context window monitor that shows token usage, warns when approaching limits, suggests /compact at optimal times, and tracks context efficiency across sessions.

Why it teaches context management: Context is precious in Claude Code. You’ll understand token counting, context compaction, the /clear and /compact commands, and how to optimize context usage for long development sessions.

Core challenges you’ll face:

• Token tracking (monitoring current usage) → maps to context window mechanics
• Threshold detection (knowing when to compact) → maps to context optimization
• Compaction timing (optimal /compact moments) → maps to workflow efficiency
• Usage analytics (tracking patterns over time) → maps to productivity insights

Key Concepts:

• Context Management: “Claude Code Best Practices” - Anthropic Engineering Blog
• Token Economics: Anthropic Pricing Documentation
• Optimization: “Designing Data-Intensive Applications” Chapter 1 - Martin Kleppmann

Difficulty: Intermediate Time estimate: 1 week Prerequisites: Understanding of token counting, bash scripting

Real world outcome:

# Status bar integration (via statusLine):
[Claude] 45,000/128,000 tokens (35%) | Session: 2h 15m | ⚡ Efficient

# When approaching limit:
[Claude] 108,000/128,000 tokens (84%) | ⚠️ Consider /compact

# Analytics dashboard:
$ context-monitor stats

Session Statistics:
==================
Average token efficiency: 72%
Most token-heavy operations:
  1. Large file reads (25%)
  2. Code generation (20%)
  3. Web fetches (15%)

Recommendations:
- Use @file references instead of pasting code
- Run /compact after major milestones
- Consider splitting into multiple sessions

Learning milestones:

1. Token count displays correctly → You understand context tracking
2. Warnings trigger appropriately → You understand thresholds
3. Compaction suggestions are helpful → You understand optimization
4. Analytics provide insights → You’ve achieved productivity monitoring

---

Project 17: Skill Auto-Activation Engine

• File: PROJECT_17_SKILL_AUTO_ACTIVATE.md
• Main Programming Language: Python or Node.js
• Alternative Programming Languages: Go, Rust
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Skills / NLP / Context Detection
• Software or Tool: Claude Code Skills, Hooks
• Main Book: “Natural Language Processing with Python” by Steven Bird

What you’ll build: A UserPromptSubmit hook with a skill-rules.json configuration that analyzes prompts and file context to automatically suggest or activate relevant skills—solving the “skills don’t auto-activate” problem documented in the infrastructure showcase.

Why it teaches skill activation: Skills are powerful but require Claude to recognize when to use them. You’ll understand skill discovery, trigger patterns, context-aware activation, and how to bridge the gap between user intent and skill invocation.

Core challenges you’ll face:

• Intent detection (what does the user want?) → maps to NLP classification
• Context analysis (what files are relevant?) → maps to context understanding
• Skill matching (which skill fits?) → maps to skill discovery
• Activation timing (when to suggest vs auto-activate) → maps to UX design

Key Concepts:

• Skill Discovery: “Claude Code Skills” - https://code.claude.com/docs/en/skills.md
• Intent Classification: “Natural Language Processing with Python” Chapter 6 - Steven Bird
• Context Detection: Infrastructure Showcase patterns

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: NLP basics, understanding of skills

Real world outcome:

// skill-rules.json
{
  "rules": [
    {
      "pattern": "pdf|form|document extraction",
      "filePatterns": ["*.pdf"],
      "skill": "pdf-processing",
      "action": "auto-activate"
    },
    {
      "pattern": "database|query|slow|optimize",
      "filePatterns": ["*.sql", "migrations/*"],
      "skill": "db-analyzer",
      "action": "suggest"
    }
  ]
}

$ claude
> This PDF form needs to be filled out

[Skill Engine detects: "pdf" keyword + document context]
[Auto-activating: pdf-processing skill]

Claude (with pdf-processing skill): I'll use the PDF processing skill
to help you fill out this form...

Learning milestones:

1. Rules match correctly → You understand pattern matching
2. Context enhances matching → You understand context analysis
3. Skills activate automatically → You understand skill triggering
4. UX is smooth → You’ve achieved seamless activation

---

Project 18: TDD Enforcement System (CodePro-style)

• File: PROJECT_18_TDD_ENFORCEMENT.md
• Main Programming Language: Bash + Python
• Alternative Programming Languages: Node.js, Go
• Coolness Level: Level 4: Hardcore Tech Flex
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: TDD / Quality Assurance / Workflow Enforcement
• Software or Tool: Claude Code Hooks, Testing Frameworks
• Main Book: “Test Driven Development: By Example” by Kent Beck

What you’ll build: A hook-based TDD enforcement system inspired by Claude CodePro—production code written before tests is flagged, tests must fail first before implementation, and actual test output is required (no assumptions).

Why it teaches quality enforcement: You’ll understand how to use hooks to enforce development workflows, track file modification order, integrate with test runners, and create guardrails that ensure quality without blocking productivity.

Core challenges you’ll face:

• Write order tracking (tests before implementation) → maps to file modification tracking
• Test execution verification (must actually run) → maps to test runner integration
• Failure-first validation (tests must fail first) → maps to TDD enforcement
• Developer experience (enforcement without frustration) → maps to UX design

Key Concepts:

• TDD: “Test Driven Development: By Example” - Kent Beck
• Hooks for Enforcement: “Claude Code Hooks Guide” - https://code.claude.com/docs/en/hooks-guide.md
• Quality Gates: “Continuous Delivery” Chapter 4 - Jez Humble

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: TDD concepts, testing frameworks, hook development

Real world outcome:

$ claude
> add a new user validation function

[TDD ENFORCER] Starting TDD workflow...

Claude: First, I'll write the test for user validation:
[Writes: test/user.test.js]

[TDD ENFORCER] Running test...
[TDD ENFORCER] ✓ Test fails as expected (function doesn't exist)

Claude: Now I'll implement the function:
[Writes: src/user.js]

[TDD ENFORCER] Running test...
[TDD ENFORCER] ✓ Test passes!
[TDD ENFORCER] ✓ TDD workflow completed successfully

# If you try to skip tests:
> just write the implementation without tests

[TDD ENFORCER] ❌ BLOCKED: No test file exists for src/user.js
[TDD ENFORCER] Please write tests first following TDD practices.

Learning milestones:

1. Test-first order enforced → You understand modification tracking
2. Tests actually execute → You understand test integration
3. Failures required first → You understand TDD enforcement
4. Developer experience is smooth → You’ve achieved practical TDD

---

Project 19: CLAUDE.md Generator & Analyzer

• File: PROJECT_19_CLAUDEMD_TOOLS.md
• Main Programming Language: Python or TypeScript
• Alternative Programming Languages: Go, Rust
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 2. The “Micro-SaaS / Pro Tool”
• Difficulty: Level 2: Intermediate (The Developer)
• Knowledge Area: Context / Documentation / Code Analysis
• Software or Tool: Claude Code CLAUDE.md
• Main Book: “The Pragmatic Programmer” by David Thomas

What you’ll build: A tool that analyzes your codebase and generates an optimal CLAUDE.md file—detecting project structure, frameworks, conventions, testing patterns, and key architectural decisions to give Claude the best possible context.

Why it teaches CLAUDE.md optimization: CLAUDE.md is the foundation of Claude’s project understanding. You’ll understand what information helps Claude most, how to structure context efficiently, and how to maintain project memory across sessions.

Core challenges you’ll face:

• Codebase analysis (detecting patterns and structure) → maps to static analysis
• Context prioritization (what matters most?) → maps to information architecture
• Format optimization (clear, scannable, efficient) → maps to documentation design
• Maintenance (keeping CLAUDE.md current) → maps to automation

Key Concepts:

• CLAUDE.md: “Claude Code Configuration” - https://code.claude.com/docs/en/configuration.md
• Project Documentation: “The Pragmatic Programmer” Chapter 8 - David Thomas
• Static Analysis: “Working Effectively with Legacy Code” - Michael Feathers

Difficulty: Intermediate Time estimate: 1 week Prerequisites: Understanding of code analysis, documentation patterns

Real world outcome:

$ claudemd generate

Analyzing codebase...
✓ Detected: TypeScript + React + Node.js
✓ Found: Jest for testing
✓ Found: ESLint + Prettier
✓ Detected: 47 API endpoints
✓ Found: PostgreSQL schema
✓ Analyzed: 156 components

Generated CLAUDE.md:
=====================
# Project: E-commerce Platform

## Tech Stack
- Frontend: React 18 + TypeScript
- Backend: Node.js + Express
- Database: PostgreSQL
- Testing: Jest + React Testing Library

## Project Structure
- /src/components - React components (156 files)
- /src/api - Express routes (47 endpoints)
- /src/models - Database models (12 tables)

## Conventions
- Use functional components with hooks
- API responses follow { data, error, meta } pattern
- Tests live alongside source files (*.test.ts)

## Key Commands
- npm run dev - Start development server
- npm test - Run test suite
- npm run build - Production build

[Confidence Score: 94%]

Learning milestones:

1. Codebase analyzed correctly → You understand static analysis
2. Key information extracted → You understand context prioritization
3. CLAUDE.md is useful → You understand documentation design
4. Updates are automated → You’ve achieved maintenance automation

---

Project 20: Claude Code Metrics Dashboard

• File: PROJECT_20_METRICS_DASHBOARD.md
• Main Programming Language: Python + React/Vue
• Alternative Programming Languages: Node.js full-stack
• Coolness Level: Level 3: Genuinely Clever
• Business Potential: 3. The “Service & Support” Model
• Difficulty: Level 3: Advanced (The Engineer)
• Knowledge Area: Analytics / Observability / Data Visualization
• Software or Tool: Claude Code, SQLite/PostgreSQL
• Main Book: “Designing Data-Intensive Applications” by Martin Kleppmann

What you’ll build: A comprehensive dashboard that tracks Claude Code usage across sessions—cost analysis, tool usage patterns, productivity metrics, session durations, and AI effectiveness measurements (code accepted vs rejected).

Why it teaches observability: Understanding how you use Claude Code helps optimize your workflow. You’ll master data collection (via hooks), metric aggregation, trend analysis, and creating actionable insights from AI-assisted development patterns.

Core challenges you’ll face:

• Data collection (capturing usage via hooks) → maps to event capture
• Storage design (efficient metric storage) → maps to database design
• Aggregation (meaningful statistics) → maps to data analysis
• Visualization (actionable dashboards) → maps to data presentation

Key Concepts:

• Observability: “Designing Data-Intensive Applications” Chapter 10 - Martin Kleppmann
• Metrics Design: “Site Reliability Engineering” - Google
• Data Visualization: D3.js or Chart.js documentation

Difficulty: Advanced Time estimate: 2-3 weeks Prerequisites: Full-stack development, database design, data visualization

Real world outcome:

Claude Code Metrics Dashboard
=============================

Weekly Summary (Dec 14-20, 2024)
--------------------------------
Sessions: 23 | Total Time: 18h 45m | Cost: $12.34

Tool Usage:
  Edit      ████████████████ 45%
  Bash      ████████████ 30%
  Read      ████████ 20%
  WebFetch  ██ 5%

Code Acceptance Rate:
  Accepted: 87% | Modified: 10% | Rejected: 3%

Most Productive Sessions:
  1. auth-refactor (2h 15m) - 847 lines changed
  2. api-migration (1h 45m) - 623 lines changed

Insights:
  - You're most productive on Tuesdays (3.2x average)
  - Opus model has 12% higher acceptance rate
  - WebFetch usage up 45% this week

Recommendations:
  - Consider using Plan Mode for large changes
  - Your context efficiency is 68% - try /compact more often

Learning milestones:

1. Data captures automatically → You understand event collection
2. Metrics aggregate correctly → You understand data processing
3. Dashboard displays insights → You understand visualization
4. Recommendations are actionable → You’ve achieved observability

---

Project Comparison Table

#	Project	Difficulty	Time	Depth	Coolness	Business
1	Pre-Commit Hook Guardian	Intermediate	Weekend	⭐⭐⭐	Level 3	Service
2	Auto-Formatting Hook	Intermediate	1-2 days	⭐⭐	Level 2	Micro-SaaS
3	Database Query Skill	Intermediate	Weekend	⭐⭐⭐	Level 3	Service
4	MCP File Watcher	Advanced	1-2 weeks	⭐⭐⭐⭐	Level 4	Open Core
5	CI/CD PR Reviewer	Intermediate	3-5 days	⭐⭐⭐	Level 3	Service
6	Security Subagent	Intermediate	2-3 days	⭐⭐⭐	Level 3	Service
7	Session Manager CLI	Intermediate	Weekend	⭐⭐⭐	Level 3	Micro-SaaS
8	Permission Policy Engine	Advanced	1 week	⭐⭐⭐⭐	Level 3	Service
9	Prompt Enhancer Hook	Advanced	1-2 weeks	⭐⭐⭐⭐	Level 4	Service
10	Worktree Orchestrator	Advanced	1 week	⭐⭐⭐⭐	Level 4	Micro-SaaS
11	Output Style System	Intermediate	2-3 days	⭐⭐	Level 2	Micro-SaaS
12	MCP Resource Browser	Advanced	1-2 weeks	⭐⭐⭐⭐	Level 4	Open Core
13	Sandbox Escape Detector	Expert	2-3 weeks	⭐⭐⭐⭐⭐	Level 5	Service
14	Extended Thinking Analyzer	Advanced	1-2 weeks	⭐⭐⭐	Level 3	Resume Gold
15	Plugin Development Kit	Advanced	2-3 weeks	⭐⭐⭐⭐	Level 4	Disruptor
16	Context Window Monitor	Intermediate	1 week	⭐⭐⭐	Level 3	Micro-SaaS
17	Skill Auto-Activation	Advanced	1-2 weeks	⭐⭐⭐⭐	Level 4	Service
18	TDD Enforcement System	Advanced	1-2 weeks	⭐⭐⭐⭐	Level 4	Service
19	CLAUDE.md Generator	Intermediate	1 week	⭐⭐⭐	Level 3	Micro-SaaS
20	Metrics Dashboard	Advanced	2-3 weeks	⭐⭐⭐⭐	Level 3	Service

---

Recommended Learning Path

Beginner Path (Start Here)

1. Project 1: Pre-Commit Hook Guardian → Learn hooks basics
2. Project 2: Auto-Formatting Hook → Master PostToolUse
3. Project 3: Database Query Skill → Understand skills
4. Project 11: Output Style System → Learn system prompts

Intermediate Path

1. Project 5: CI/CD PR Reviewer → Master headless mode
2. Project 6: Security Subagent → Understand subagents
3. Project 7: Session Manager CLI → Master sessions
4. Project 16: Context Window Monitor → Understand context

Advanced Path

1. Project 4: MCP File Watcher → Build MCP servers
2. Project 8: Permission Policy Engine → Master permissions
3. Project 9: Prompt Enhancer Hook → Advanced hooks
4. Project 12: MCP Resource Browser → MCP resources

Expert Path

1. Project 10: Worktree Orchestrator → Parallel development
2. Project 15: Plugin Development Kit → Full plugin system
3. Project 17: Skill Auto-Activation → Advanced skills
4. Project 18: TDD Enforcement → Quality workflows
5. Project 13: Sandbox Escape Detector → Security mastery

Capstone Projects

1. Project 14: Extended Thinking Analyzer → Reasoning analysis
2. Project 19: CLAUDE.md Generator → Context optimization
3. Project 20: Metrics Dashboard → Full observability

---

Final Capstone: Claude Code Power User Toolkit

After completing the projects above, build a comprehensive toolkit that combines:

• Unified hook system (Projects 1, 2, 9, 18)
• Custom skill library (Projects 3, 17)
• MCP server suite (Projects 4, 12)
• Subagent collection (Project 6)
• Session management (Projects 7, 10)
• Security policies (Projects 8, 13)
• Analytics dashboard (Projects 16, 20)
• Full plugin (Project 15)

Real world outcome: A publishable Claude Code plugin that transforms Claude into a production-grade AI development environment with:

• Automated code quality enforcement
• Intelligent context management
• Real-time observability
• Enterprise-ready security
• Team-shareable configurations

This toolkit would be a genuine contribution to the Claude Code ecosystem and demonstrate mastery of every advanced technique.

---

Resources Summary

Official Documentation

• Claude Code Overview
• CLI Reference
• Hooks Guide
• Skills Guide
• MCP Integration
• Settings & Permissions
• Headless Mode

Community Resources

• Anthropic Engineering Blog
• Claude Code Infrastructure Showcase
• Claude CodePro
• MCP Protocol

Books

• “Effective Shell” by Dave Kerr
• “Node.js Design Patterns” by Mario Casciaro
• “The Pragmatic Programmer” by David Thomas
• “Test Driven Development” by Kent Beck
• “Designing Data-Intensive Applications” by Martin Kleppmann