Claude Copilot Learning Roadmap

Claude Copilot Learning Roadmap

New to Claude Copilot? This comprehensive guide will help you master the framework progressively, from basic memory persistence to advanced team customization.

Learning Philosophy

This roadmap follows three key principles:

1. Dependencies - Build foundational capabilities before advanced features
2. Value First - Get immediate productivity wins at each stage
3. Practical Application - Learn by doing with copy-paste ready commands

Each milestone delivers tangible value. You can stop at any stage and already have a dramatically improved workflow.

Your Learning Path

graph TD
    A[Milestone 1: Memory<br/>Persistent Context] --> B[Milestone 2: Protocol<br/>Structured Workflow]
    B --> C[Milestone 3: Agents<br/>Specialist Team]
    C --> D[Milestone 4: Extensions<br/>Team Knowledge]
    D --> E[Milestone 5: Mastery<br/>Custom Solutions]

    style A fill:#90EE90
    style B fill:#87CEEB
    style C fill:#FFD700
    style D fill:#FFA500
    style E fill:#FF6347

Color Legend:

• Green: Essential - Memory that survives sessions
• Light Blue: Core - Structured workflows
• Gold: Power User - Full specialist team
• Orange: Team - Shared knowledge
• Red: Advanced - Custom solutions

Complete Roadmap Table

Quick Start Paths

If You Only Have 15 Minutes

Goal: Get memory working so /continue actually works

# 1. Clone to standard location
mkdir -p ~/.claude && cd ~/.claude
git clone https://github.com/Everyone-Needs-A-Copilot/claude-copilot.git copilot

# 2. Machine setup
cd ~/.claude/copilot && claude

Then say:

Read @~/.claude/copilot/SETUP.md and set up Claude Copilot on this machine

What you get: Memory Copilot running - your work persists between sessions.

If You Have 1 Hour

Goal: Memory + Protocol + core agents (ta, me, qa)

Follow the 15-minute path, then:

# Set up a project
cd ~/your-project && claude

Run:

/setup-project

Then try:

/protocol
# Say: "I need to add user authentication"
# Watch as ta (Tech Architect) breaks it down

What you get: Structured workflows with expert guidance.

If You Have a Weekend

Goal: Full framework + team knowledge repository

Phase 1 - Complete Milestones 1-3 Phase 2 - Set up knowledge repository Phase 3 - Create custom extensions for your domain

What you get: Complete development team + company knowledge accessible everywhere.

Milestone 1: Persistent Memory

Complexity: Beginner Prerequisites: None Goal: Work survives sessions - decisions, context, and progress persist

What You'll Achieve

• Memory Copilot installed and running
• /continue loads your previous session
• Decisions and lessons automatically stored
• Never start from zero again

The Problem This Solves

Claude Code normally forgets everything when you close it. You repeat context, explain decisions, and lose progress. Memory Copilot fixes this.

Hands-on Exercise

# 1. Clone repository
mkdir -p ~/.claude && cd ~/.claude
git clone https://github.com/Everyone-Needs-A-Copilot/claude-copilot.git copilot

# 2. Open in Claude Code
cd ~/.claude/copilot && claude

Then say:

Read @~/.claude/copilot/SETUP.md and set up Claude Copilot on this machine

This installs:

• Memory Copilot MCP server (persistent storage)
• Skills Copilot MCP server (knowledge + skills)
• Global commands (/setup-project, /knowledge-copilot, etc.)

Verification

In Claude Code, run:

/mcp

You should see:

● copilot-memory
● skills-copilot

What You Can Do Now

Understanding Memory Tools

Claude Copilot adds these tools to Claude Code:

Success Criteria

• Machine setup completed
• Both MCP servers show as connected
• You understand what Memory Copilot does
• You're ready to set up a project

What's Next?

Memory alone is valuable, but the real power comes from combining it with structured workflows. That's Milestone 2.

Milestone 2: Agent Workflow

Complexity: Beginner+ Prerequisites: Memory Copilot installed Goal: Start using /protocol for structured, expert-guided work sessions

What You'll Achieve

• /protocol breaks down complex requests
• Tasks automatically routed to right specialist
• Structured session with clear next steps
• Work properly saved for /continue

The Problem This Solves

You say "add user auth" and Claude either gives generic advice or starts coding without planning. Protocol adds structure: classify → route → expert guidance → save progress.

Hands-on Exercise

# 1. Open any project in Claude Code
cd ~/your-project && claude

# 2. Set up the project
/setup-project

This creates:

your-project/
├── .mcp.json              # MCP configuration
├── CLAUDE.md              # Project instructions
└── .claude/
    ├── commands/          # /protocol, /continue
    └── agents/            # 12 specialist agents

Try Your First Protocol Session

/protocol

When prompted, say:

I need to add user authentication to this app

Watch what happens:

1. Classification: Task identified as "Feature Implementation"
2. Routing: Sent to Tech Architect (ta)
3. Breakdown: Architecture decisions + task list
4. Saved: Everything stored in memory for /continue

Understanding Protocol Flow

graph TD
    A[User Request] --> B{Protocol Classifies}
    B -->|Bug Fix| C[Engineer me]
    B -->|Feature| D[Tech Architect ta]
    B -->|Security| E[Security sec]
    B -->|Design| F[UX Designer uxd]
    C --> G[Work + Save]
    D --> G
    E --> G
    F --> G
    G --> H[Continue Later]

Protocol Request Types

Verification

# 1. Start protocol session
/protocol
# Say: "Add dark mode toggle"

# 2. Let it complete

# 3. Close and reopen Claude Code

# 4. Resume work
/continue

You should see your previous session load with full context.

What You Can Do Now

Success Criteria

• /setup-project completed on a test project
• Ran /protocol with a request
• Saw task breakdown from an agent
• Used /continue to resume work
• Understand protocol → agent → memory flow

What's Next?

You've seen one agent in action. Milestone 3 introduces all 12 specialists and shows how they work together.

Milestone 3: Full Framework

Complexity: Intermediate Prerequisites: Protocol working Goal: Master all 14 agents and understand when to use each

What You'll Achieve

• Know all 12 specialist agents
• Understand agent routing patterns
• Use agents for complex multi-domain tasks
• See agents collaborate on solutions

The Problem This Solves

Complex work requires multiple perspectives: architecture, security, UX, implementation, testing. Managing this yourself is overwhelming. Agents handle routing and collaboration automatically.

Your Team

Hands-on Exercises

Exercise 1: Multi-Agent Feature

/protocol

Request:

Design and implement a user profile page with avatar upload

Watch the routing:

1. ta (Tech Architect) - Breaks down architecture
2. uxd (UX Designer) - Designs the flow
3. sec (Security) - Reviews file upload security
4. uid (UI Developer) - Implements components
5. qa (QA Engineer) - Tests edge cases

Exercise 2: Direct Agent Invocation

You can also talk directly to agents:

@ta What's the best way to structure a multi-tenant SaaS backend?

@sec Review this authentication middleware

@uxd Design an onboarding flow for first-time users

Exercise 3: Agent Collaboration

Complex requests trigger multiple agents:

/protocol

Request:

We need to add payment processing to the checkout flow

Expected routing:

• ta - Architecture (payment providers, webhook handling)
• sec - Security (PCI compliance, token handling)
• uxd - UX (payment form, error states)
• uid - Implementation (form components)
• qa - Testing (failed payments, edge cases)

Understanding Agent Routing

Agents route to each other based on expertise:

graph LR
    A[Any Agent] --> B[ta: Architecture]
    A --> C[sec: Security]
    D[sd: Service Design] --> E[uxd: UX Design]
    E --> F[uids: UI Design]
    F --> G[uid: UI Dev]
    A --> H[me: Engineering]
    A --> I[qa: Testing]
    A --> J[doc: Documentation]

Agent Decision Authority

Each agent knows when to work autonomously vs. escalate:

Verification Exercise

Create a complex request that requires multiple domains:

/protocol

Request:

We need to migrate our authentication from sessions to JWTs

Expected flow:

1. ta classifies as architecture change
2. ta breaks down migration strategy
3. sec reviews security implications
4. me implements changes
5. qa creates test scenarios
6. doc updates authentication docs

Success Criteria

• Understand all 14 agents and their domains
• Completed multi-agent feature exercise
• Invoked agents directly with @
• Saw agents route to each other
• Understand autonomous vs. escalation decisions

What You Can Do Now

What's Next?

You're now using the full framework solo. Milestone 4 adds team capabilities: shared knowledge, company standards, and custom extensions.

Milestone 4: Team Setup

Complexity: Intermediate+ Prerequisites: All agents working Goal: Set up shared knowledge repository and understand extensions

What You'll Achieve

• Knowledge repository for company information
• Shared standards accessible in all projects
• Custom agent extensions for your domain
• Team can share one knowledge source

The Problem This Solves

Every team member explains company context separately. Standards drift. Domain expertise gets lost. Knowledge repositories centralize this and make it available everywhere.

Two-Tier Knowledge System

Key insight: Set up global once, every project automatically gets it.

Hands-on Exercise: Create Knowledge Repository

/knowledge-copilot

This guided setup:

1. Creates Git repository for your knowledge
2. Walks through documenting:
   • Company information
   • Voice and tone guidelines
   • Product domain knowledge
   • Engineering standards
3. Helps push to GitHub for team sharing
4. Links to ~/.claude/knowledge

What Goes In Knowledge?

your-company-knowledge/
├── knowledge-manifest.json       # Required metadata
├── COMPANY.md                    # About the company
├── VOICE-AND-TONE.md            # Writing guidelines
├── PRODUCTS.md                   # Product domain
├── ENGINEERING-STANDARDS.md      # Tech standards
└── .claude/
    └── extensions/
        ├── ta.extension.md       # Custom architect guidance
        ├── sec.override.md       # Company security policies
        └── uxd.extension.md      # Design system patterns

Extension Types

Example Extension: Custom Security Standards

Create ~/.claude/knowledge/.claude/extensions/sec.extension.md:

---
name: sec
type: extension
extends: sec
description: Company security standards
---

## Security Standards

### Authentication
- Use Auth0 for all applications
- JWT tokens expire in 15 minutes
- Refresh tokens valid for 7 days

### Data Privacy
- All PII must be encrypted at rest
- Use our central KMS for key management
- Log access to sensitive data

### Code Review Requirements
- Security-sensitive code needs sec team approval
- Use our SAST tool in CI/CD
- Document threat model in ADRs

This extends the base sec agent with your company's specific requirements.

Team Member Setup

Once knowledge repository is on GitHub:

# 1. Clone team knowledge
git clone git@github.com:company/knowledge.git ~/company-knowledge

# 2. Link it
ln -sf ~/company-knowledge ~/.claude/knowledge

# 3. Done - every project now has access

Verification

/protocol

Request:

@sec Review this authentication code

Security agent should now reference your company standards (Auth0, JWT expiry, etc.) instead of just generic advice.

Check Extension Status

Use Skills Copilot tools:

Ask Claude: "Show me all loaded extensions"

Or:

Ask Claude: "Check manifest status"

Success Criteria

• Created knowledge repository with /knowledge-copilot
• Documented company information
• Created at least one agent extension
• Pushed to GitHub for team sharing
• Verified agents use custom knowledge
• Team member can clone and link

What You Can Do Now

What's Next?

Milestone 5 covers advanced customization: private skills, custom workflows, and integration patterns.

Milestone 5: Power User

Complexity: Advanced Prerequisites: Knowledge repository working Goal: Master advanced customization and workflow optimization

What You'll Achieve

• Private skills database for proprietary patterns
• Custom workflows for your domain
• Integration with external tools
• Complete framework mastery

The Problem This Solves

Every team has proprietary patterns, internal tools, and unique workflows. Power user features let you codify and automate these.

Advanced Capabilities

1. Private Skills Database

Store proprietary skills in PostgreSQL:

// .mcp.json
{
  "mcpServers": {
    "skills-copilot": {
      "env": {
        "POSTGRES_URL": "postgresql://user:pass@localhost/skills",
        "LOCAL_SKILLS_PATH": "./.claude/skills"
      }
    }
  }
}

Then use skill_save to store company-specific patterns:

Ask Claude: "Save this error handling pattern as a private skill"

2. Skills Marketplace Integration

Access 25,000+ public skills:

{
  "mcpServers": {
    "skills-copilot": {
      "env": {
        "SKILLSMP_API_KEY": "your-api-key"
      }
    }
  }
}

Skills auto-invoke based on context. No manual management.

3. Custom Workflows

Create project-specific commands in .claude/commands/:

Example: .claude/commands/deploy.md

---
name: deploy
description: Deploy with our company process
---

# Deploy Process

1. Load deployment skill: skill_get("company-deployment")
2. Check for sec approval in initiative
3. Run pre-deployment checklist
4. Execute deployment steps
5. Update initiative with deployment info
6. Notify team via memory_store

4. Workspace Identity

Preserve memory across renames/moves:

{
  "mcpServers": {
    "copilot-memory": {
      "env": {
        "WORKSPACE_ID": "explicit-project-name"
      }
    }
  }
}

Default is path-based hash. Set explicitly for portability.

Hands-on Exercises

Exercise 1: Create Private Skill

1. Document your company's API error handling pattern
2. Ask Claude to save it: "Save this as a private skill named 'company-error-handling'"
3. Test retrieval: "Load the company-error-handling skill"
4. Use it: "Apply our error handling to this endpoint"

Exercise 2: Custom Command

Create .claude/commands/release.md:

---
name: release
description: Our release process
---

You are managing a release following our company process.

## Steps

1. Verify all tests pass (check with qa)
2. Review security concerns (check with sec)
3. Update changelog (check with doc)
4. Create release branch
5. Deploy to staging
6. Run smoke tests
7. Get approval
8. Deploy to production
9. Update initiative: "Release vX.X.X completed"

Follow these steps and confirm each before proceeding.

Then use: /release

Exercise 3: Multi-Project Memory

Set up related projects to share memory:

Project A .mcp.json:

{
  "mcpServers": {
    "copilot-memory": {
      "env": {
        "WORKSPACE_ID": "shared-platform"
      }
    }
  }
}

Project B .mcp.json:

{
  "mcpServers": {
    "copilot-memory": {
      "env": {
        "WORKSPACE_ID": "shared-platform"
      }
    }
  }
}

Now decisions in Project A are accessible in Project B.

Advanced Patterns

Pattern 1: Agent Specialization

Override agents for narrow domains:

~/.claude/knowledge/.claude/extensions/me.override.md:

---
name: me
type: override
description: React Native specialist
---

## Identity

**Role:** React Native Engineer
**Mission:** Build performant cross-platform mobile apps

## React Native Expertise

- Always use TypeScript
- Follow our RN performance guidelines
- Use our component library
- Test on both iOS and Android
- [... specialized guidance ...]

Pattern 2: Workflow Automation

Chain commands together:

.claude/commands/feature.md:

---
name: feature
description: Full feature workflow
---

Execute our complete feature workflow:

1. /protocol - Let ta break down architecture
2. Load security checklist - skill_get("security-checklist")
3. Implement with me
4. Test with qa
5. Document with doc
6. Update initiative with "Feature complete"

Confirm each step before proceeding.

Pattern 3: Knowledge Layering

Override global knowledge at project level:

.mcp.json:

{
  "mcpServers": {
    "skills-copilot": {
      "env": {
        "KNOWLEDGE_REPO_PATH": "./project-knowledge"
      }
    }
  }
}

Resolution order:

1. Project knowledge (KNOWLEDGE_REPO_PATH)
2. Global knowledge (~/.claude/knowledge)
3. Base agents

Success Criteria

• Set up private skills database or marketplace access
• Created custom command for your workflow
• Built at least one agent override
• Understand workspace identity
• Tested advanced integration patterns
• Can train team members on framework

What You Can Do Now

Beyond Mastery

You're now a Claude Copilot power user. Consider:

1. Train your team - Share knowledge and best practices
2. Contribute - Submit agents/skills to community
3. Extend - Build custom MCP servers for your tools
4. Optimize - Continuously improve based on usage
5. Document - Create guides for your specific domain

Progress Tracking

Use this checklist to track your journey:

Milestone 1: Memory

• Cloned claude-copilot to ~/.claude/copilot
• Ran machine setup (/setup)
• Verified MCP servers connected
• Understand memory_store and memory_search
• Can explain what Memory Copilot does

Milestone 2: Protocol

• Ran /setup-project in a test project
• Started first /protocol session
• Saw task breakdown from agent
• Closed and used /continue to resume
• Understand protocol → agent → memory flow

Milestone 3: Agents

• Know all 14 agents and their domains
• Completed multi-agent feature
• Used @ to invoke agents directly
• Saw agents route to each other
• Understand autonomous vs. escalation

Milestone 4: Team

• Created knowledge repository
• Documented company information
• Created agent extension
• Pushed to GitHub
• Team member cloned and linked
• Verified agents use custom knowledge

Milestone 5: Mastery

• Set up private skills or marketplace
• Created custom command
• Built agent override
• Tested advanced patterns
• Can train others
• Framework fully integrated into workflow

Learning Tips

Do

• Follow the milestone order - Each builds on previous
• Complete verification steps - Confirm it works before moving on
• Experiment safely - Use test projects for learning
• Document your patterns - Create company-specific guides
• Share with team - Learn together, share discoveries

Don't

• Skip Memory setup - Nothing else works without it
• Rush to extensions - Master base agents first
• Copy configs blindly - Understand what each setting does
• Work in isolation - Collaborate on knowledge repository
• Forget to /continue - Always save progress at session end

Common Challenges

Challenge 1: "MCP servers won't connect"

Solution:

1. Check .mcp.json uses absolute paths (not ~)
2. Verify dist/index.js files exist
3. Run: cd ~/.claude/copilot/mcp-servers/copilot-memory && npm run build
4. Restart Claude Code

Challenge 2: "/continue doesn't load context"

Solution:

1. Verify copilot-memory is connected: /mcp
2. Check you ran /protocol (not just chatted)
3. Look for initiative_update calls in previous session
4. Ensure WORKSPACE_ID is consistent

Challenge 3: "Agents give generic advice"

Solution:

1. Create knowledge repository with company context
2. Add agent extensions with domain specifics
3. Use /protocol (not direct chat) for proper routing
4. Be specific in requests: "using our React patterns" vs "add feature"

Challenge 4: "Which agent do I use?"

Solution:

• Use /protocol - routing is automatic
• For direct invocation: @ta (design), @me (code), @qa (test), @sec (security), @doc (write)
• Check the agent routing diagram in Milestone 3

Challenge 5: "Team members have different experiences"

Solution:

1. All use same knowledge repository (clone from GitHub)
2. All link: ln -sf ~/company-knowledge ~/.claude/knowledge
3. Document team setup in knowledge repo README
4. Version control knowledge repo for consistency

What's Next After Completion?

Once you've completed all milestones:

1. Team Enablement - Train teammates, create onboarding docs
2. Knowledge Curation - Continuously improve company knowledge
3. Workflow Optimization - Refine agents and commands based on usage
4. Community Contribution - Share generic patterns back to framework
5. Advanced Integration - Build custom MCP servers for your tools
6. Stay Updated - Watch for framework updates and new capabilities

Additional Resources

Documentation

Community

• GitHub Repository
• Releases
• Issues

Feedback & Support

• Found an issue? Create an issue
• Have a suggestion? Submit a pull request
• Need help? Check documentation or ask in discussions

Last Updated: December 2025 Maintained by: Everyone Needs a Copilot License: MIT

← Back to README