Lesson 50: Capstone — Design, Build & Ship

Day 50 of 50 · ~30 min · Phase 6: Mastery

The Final Question

Fifty lessons ago, you asked: What is Claude Code? How does it help me?

Today, you ask something different: I've learned the foundations, built agents, created skills, understood the agentic loop. Now what? How do I actually use all of this in my real work? What's my next move?

This final lesson isn't new concepts. It's a reflection, a design exercise, a build exercise, and a shipping exercise. By the end, you'll have a personal Claude Code setup that's optimized for your workflow — configured, tested, and ready to ship.

Part 1: Reflect on the Journey

Before you build forward, let's look back. You've covered 49 lessons across 6 phases. Let's trace the path.

Phase 1: Foundations (Lessons 1-5) You learned what Claude Code is: an AI agent that reads, reasons, and acts on your codebase. You understood the agentic loop: read → reason → act → check.

Phase 2: Tools & Context (Lessons 6-11) You learned how Claude sees your project through tools, manages its knowledge with context windows, and learns your style through CLAUDE.md.

Phase 3: Customization (Lessons 12-15) You learned to control what Claude can do (permissions), give it shortcuts (commands), teach it memory (rules), and reuse workflows (skills).

Phase 4: Integrations (Lessons 16-20) You learned to connect Claude to the world: MCP for external services, IDE integrations for your editor, plugin systems for sharing.

Phase 5: Advanced Patterns (Lessons 21-44) You learned sophisticated patterns: subagents for parallelism, headless mode for automation, cost optimization, debugging, extended thinking, checkpointing, working with large codebases, security, channels, cloud providers, and monitoring.

Phase 6: Mastery (Lessons 45-50) You learned the foundations: the Agent SDK that powers Claude Code, building custom agents, teams of agents, plugins as distribution, and building something real.

Pause and think: Which phase taught you the most? Where did your understanding shift the most?

Part 2: Design Your Workflow

Now let's design your personal setup. Answer these questions:

Question 1: What's your primary use case?

Pick the top one (or two) things you want Claude Code to help with:

Options:

• Code review and quality
• Writing tests and test coverage
• Refactoring and modernizing code
• Security audits
• Documentation generation
• Performance optimization
• Onboarding and education
• Debugging and troubleshooting
• Deployment and DevOps
• Custom domain-specific work

Example: "My primary use case is code review. I want Claude to automatically review PRs for bugs and security issues."

Question 2: What tools do you need?

Based on your use case, what does Claude need access to?

Filesystem basics: (everyone needs these)

• Read code files
• Write test files
• Edit code

Command execution:

• Run tests
• Run linters
• Run build commands
• Deploy to staging

External services:

• GitHub (MCP server for PR integration)
• Jira (MCP server for issue tracking)
• Slack (MCP server for notifications)
• Database queries (custom MCP server)

Example for code review: "I need to read files, run linters, and post comments to GitHub."

Question 3: What's your team's workflow?

Are you:

• Solo developer? → Simple setup, personal CLAUDE.md, standalone skills
• Small team (2-5 people)? → Shared CLAUDE.md in repo, team plugins, shared settings
• Larger team? → Plugin marketplace, managed settings, centralized configuration, audit logs

Example: "We're a 5-person team. We want shared code review skills and a plugin that all developers install."

Question 4: What should be automated?

Which tasks would benefit from Claude Code running without you watching?

Good candidates:

• Running tests after commit
• Linting pull requests
• Security scanning
• Generating documentation
• Refactoring common patterns

Not good candidates:

• Decisions that need human judgment
• Tasks where you need to guide Claude step-by-step
• Anything that could break your main branch

Example: "We want Claude to automatically scan PRs for security issues and comment with findings."

Question 5: What guardrails do you need?

What could go wrong, and how do you prevent it?

Guardrails to consider:

• Permissions — What can Claude read/write? (CLAUDE.md defines this)
• Costs — Which models cost too much? (extended thinking, claude-opus)
• Safety — What operations are forbidden? (destructive git commands, production deployments)
• Audit — Can you trace what Claude did and why? (logs, git commits, notifications)

Example: "Claude can review code and commit suggestions, but not push directly. All changes go through pull requests."

Part 3: Build It

Now let's construct your setup. Follow these steps:

Step 1: Create your CLAUDE.md (10 min)

At your project root (or team repo), create CLAUDE.md:

# Project Setup for Claude Code

## Project Overview
[Brief description of your project]

## How to Test
```bash
[Your test command]

Tests go in /tests and use [your test framework].

How to Build

[Your build command]

Output goes to /build or /dist.

How to Deploy

[Brief deployment process]

Code Style

• Language: [JavaScript/TypeScript/Python/etc.]
• Formatter: [Prettier/Black/etc.]
• Linter: [ESLint/Pylint/etc.]
• Naming: [camelCase/snake_case]
• Indentation: [2 spaces/4 spaces/tabs]

Project Structure

• /src — Source code
• /tests — Test files
• /docs — Documentation
• /config — Configuration files

Important Patterns

[List 3-5 patterns Claude should know]

What Claude Can Do

• Read all source code
• Run npm test and npm run build
• Create test files
• Suggest refactors

What Claude Should NOT Do

• Push to main branch
• Delete files without asking
• Deploy to production
• Modify configuration without permission

Common Commands

• Test: npm test
• Build: npm run build
• Lint: npm run lint
• Format: npm run format

Tools & Environment

• Node.js [version]
• [Any special setup or dependencies]

### Step 2: Define your permissions (5 min)

Create or update `.claude/settings.json` with your permissions:

```json
{
  "allowedTools": {
    "read_file": true,
    "write_file": true,
    "edit_file": true,
    "bash": true,
    "web_search": false
  },
  "constrainedOperations": [
    "git push",
    "npm publish",
    "rm -rf"
  ],
  "allowedDirectories": [
    "src",
    "tests",
    "docs"
  ],
  "forbiddenPatterns": [
    ".env",
    "secret*",
    "*password*"
  ]
}

Step 3: Create your skills (10 min)

Create .claude/skills/ with custom skills for your workflow:

Example: Code review skill

mkdir -p .claude/skills/code-review
cat > .claude/skills/code-review/SKILL.md << 'EOF'
---
description: Review code for bugs, security issues, and best practices
---

When reviewing code, check for:
1. **Correctness** — Does it do what it intends? Are there edge cases?
2. **Security** — Injection risks? Authentication flaws? Data leaks?
3. **Performance** — Unnecessary loops? Memory leaks?
4. **Style** — Follows project conventions? Well-named?
5. **Tests** — Is it tested? Coverage adequate?

Always be specific: cite lines, explain issues, suggest fixes.
EOF

Example: Test generator skill

mkdir -p .claude/skills/test-generator
cat > .claude/skills/test-generator/SKILL.md << 'EOF'
---
description: Generate comprehensive tests for a code file
---

When generating tests:
1. Read the code carefully
2. Identify all functions and edge cases
3. Write tests using [your test framework]
4. Aim for >80% coverage
5. Test success cases, error cases, and edge cases

Place tests in `/tests/[original-file-name].test.js`.
EOF

Step 4: Set up hooks (optional, 5 min)

If you want automation, create .claude/hooks.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint:fix -- $FILE_PATH"
          }
        ]
      }
    ]
  }
}

This automatically lints and fixes files Claude edits.

Step 5: Create your plugin (optional, 10 min)

If you want to share your setup with your team, package it as a plugin:

mkdir my-team-plugin
mkdir -p my-team-plugin/.claude-plugin
mkdir -p my-team-plugin/skills

cat > my-team-plugin/.claude-plugin/plugin.json << 'EOF'
{
  "name": "my-team-plugin",
  "description": "Team-wide Claude Code setup and skills",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}
EOF

# Copy your skills into the plugin
cp -r .claude/skills/* my-team-plugin/skills/

# Add a README
cat > my-team-plugin/README.md << 'EOF'
# My Team Plugin

This plugin provides skills and configuration for our team's Claude Code setup.

## Skills
- `/my-team-plugin:code-review` — Review code for bugs and security
- `/my-team-plugin:test-generator` — Generate test files

## Setup
1. Install: `/plugin install https://github.com/yourteam/my-team-plugin`
2. Create CLAUDE.md in your project (see plugin docs)
3. Run `/reload-plugins`

## Usage

/my-team-plugin:code-review

EOF

Part 4: Ship It

You've designed and built your setup. Now let's ship it.

For personal use:

1. Commit to your project:

   git add CLAUDE.md .claude/
   git commit -m "Add Claude Code configuration"
   git push
   

2. Test it:

   claude "Review the code in src/app.js"
   

3. Iterate: Watch Claude work. Refine CLAUDE.md based on what it struggles with.

For team use:

1. Create a team repository:

   git init my-team-plugin
   cd my-team-plugin
   git add .
   git commit -m "Initial plugin"
   git push origin main
   

2. Share the URL with your team:

   https://github.com/yourteam/my-team-plugin
   

3. Have teammates install:

   /plugin install https://github.com/yourteam/my-team-plugin
   

4. Update centrally: Change the plugin once, everyone gets updates.

For public use (optional):

1. Polish documentation in your plugin's README.

2. Test thoroughly — run your plugin, find edge cases, fix them.

3. Version properly — use semantic versioning (1.0.0, 1.1.0, 2.0.0).

4. Submit to the official marketplace:

   • Go to platform.claude.com/plugins/submit
   • Fill out the form
   • Submit for review

5. Share with the community — announce on forums, socials, dev communities.

What's Next?

Your Claude Code setup is now live. But the journey doesn't end here. Here's how to stay sharp and keep growing:

Keep Learning

• Read the official docs: code.claude.com/docs
• Follow releases: New SDK versions, new MCP servers, new capabilities
• Join communities: Anthropic forums, GitHub discussions, dev communities
• Experiment: Try new tools, new patterns, new integrations

Build and Share

• Solve your own problems: Build agents for your recurring tasks
• Share with your team: Package reusable skills as plugins
• Contribute to the ecosystem: Publish open-source plugins
• Teach others: Write guides, share your patterns, mentor

Optimize

• Monitor costs: Track token usage, optimize prompt lengths
• Measure impact: How much time does Claude save? How many bugs does it catch?
• Refine: Keep improving your CLAUDE.md, skills, and system prompts
• Automate more: Gradually move tasks from manual to Claude-assisted to fully automated

Think Bigger

• Multi-agent systems: Build teams of specialized agents
• Custom agents in your apps: Embed agents in your products
• Agent marketplaces: Create and publish specialized agents for your industry
• AI-native workflows: Redesign how your team works with AI as a first-class member

The Full Journey: All 6 Phases

Let me recap what you've mastered:

You've gone from "What is this?" to "How do I build with this?" to "How do I lead teams with this?" This is mastery.

Your Capstone Checklist

Before you go, verify you have:

• Created a CLAUDE.md for your primary project
• Defined permissions and guardrails in .claude/settings.json
• Built 2-3 custom skills for your workflow
• Tested Claude Code on a real task and refined your setup
• (Optional) Packaged a plugin for your team or community
• Committed everything to git and shared it

Final Reflection

You are no longer learning Claude Code. You are building with it.

When you started, Claude Code was a tool you didn't understand. Now, you understand its foundations (the Agent SDK), its architecture (agentic loops, tools, sessions), its ecosystem (MCP, plugins, skills), and its potential (teams of agents, custom workflows, production deployments).

You've built agents. You've created skills. You've designed systems. You've learned to think in terms of agentic workflows.

This is the difference between knowing about a technology and mastering it.

Resources to Bookmark

• Official Docs: code.claude.com/docs
• Agent SDK: platform.claude.com/docs/en/agent-sdk
• Plugin Marketplace: claude.com/plugins
• Community Forums: Anthropic forums
• GitHub: github.com/anthropics/claude-code

One More Thing

You didn't just complete a curriculum. You learned to think like an agent engineer. You learned to:

• Break down problems into tools
• Design prompts that guide behavior
• Think about edge cases and error handling
• Build systems that scale
• Share and distribute your ideas
• Iterate and improve

These skills transfer. They apply to building any AI system, not just Claude Code.

You're ready to build the next generation of AI-native tools.

Congratulations

You've completed all 50 lessons.

You came in with a question. You leave with mastery, a working setup, and the skills to teach others.

Now go build something amazing.

← Back to Curriculum