name: learning-path-builder description: | Creates personalized learning paths for technologies, frameworks, or concepts. Use for user-interactive session only for onboarding new technologies, hackathon skill-building, or personal development planning. Not for use in automated development or investigation. Sequences resources (docs, tutorials, exercises) based on current skill level and learning goals. Adapts to learning style: hands-on, theory-first, project-based.

Learning Path Builder Skill

Purpose

This skill creates personalized, structured learning paths that guide users through mastering new technologies, frameworks, or concepts. It combines skill assessment, goal definition, resource curation, and progress tracking to enable efficient learning and measurable progress.

When to Use This Skill

New Technology Adoption: Learning a new framework, language, or tool
Onboarding: Bringing team members up to speed on project technologies
Hackathon Preparation: Building required skills before a competition
Career Development: Structured path for advancing in a particular domain
Knowledge Gaps: Filling specific skill gaps in your technical stack
Upskilling: Transitioning from one technology to another
Learning Optimization: Creating efficient paths tailored to your learning style

Core Philosophy: Personalized Progressive Learning

Assessment → Goal Setting → Path Sequencing → Resource Curation → Progress Tracking → Adaptation

A good learning path:

Matches current skill level (beginner, intermediate, advanced)
Aligns with learning goals and timeline
Sequences concepts from simple to complex
Mixes multiple resource types (docs, tutorials, exercises, projects)
Provides checkpoints and milestones
Adapts to learning style and feedback

Learning Path Components

Every personalized learning path includes:

1. Skills Assessment

Current skill level (beginner/intermediate/advanced)
Relevant prior knowledge
Learning experience preference
Time availability
Career/project goals

2. Goal Definition

Primary learning objective
Target proficiency level
Timeline and milestones
Success metrics
Constraints and dependencies

3. Concept Sequence

Prerequisite concepts
Progressive complexity levels
Learning foundations first
Builds practical understanding over time

4. Resource Curation

Official documentation
High-quality tutorials
Interactive exercises
Real-world projects
Community resources

5. Learning Checkpoints

Milestone assessments
Practical exercises
Mini-projects
Reflection points
Progress validation

6. Progress Tracking

Completed modules
Assessed skill gains
Time investment
Confidence levels
Feedback integration

Step-by-Step Assessment Process

Step 1: Assess Current Skill Level

Ask targeted questions to understand:

Technical Background
- Languages/frameworks you already know
- Similar technologies you've used
- Years of programming experience
- Relevant professional experience
Learning Style Preference
- Hands-on (learn by doing)
- Theory-first (understand concepts)
- Project-based (learn via real problems)
- Visual (diagrams, videos)
- Reading (documentation, blogs)
Time Availability
- Hours per week available
- Preferred learning schedule
- Commitment timeline
- Flexibility (can vary per week)
Current Knowledge Gaps
- What specifically needs to be learned
- Existing knowledge in adjacent areas
- Misconceptions to address
- Prior learning attempts

Step 2: Define Clear Learning Goals

Establish SMART goals:

Specific: What exactly will you be able to do?
Measurable: How will you know you've succeeded?
Achievable: Is this realistic given your timeline?
Relevant: How does this align with career/project needs?
Time-bound: When do you want to achieve this?

Step 3: Sequence Concepts Progressively

Create learning sequence from foundations to advanced:

Foundation Concepts (Week 1-2)
- Core terminology
- Basic architecture
- Key principles
- Simple examples
Core Functionality (Week 2-4)
- Main features
- Common patterns
- Practical exercises
- Real examples
Advanced Topics (Week 4+)
- Complex scenarios
- Performance optimization
- Best practices
- Production deployment
Specialization (As needed)
- Domain-specific knowledge
- Integration patterns
- Advanced debugging
- Expert techniques

Step 4: Curate High-Quality Resources

For each concept, provide:

Official Documentation
- Links to relevant docs
- Specific sections to focus on
- Time estimates
- Difficulty level
Tutorials and Guides
- Author/source credibility
- Format (text, video, interactive)
- Hands-on vs theoretical
- Time to complete
Interactive Exercises
- Practice problems
- Coding exercises
- Interactive sandboxes
- Difficulty progression
Real-World Projects
- Beginner projects (1-2 days)
- Intermediate projects (1-2 weeks)
- Advanced projects (2+ weeks)
- Open-source contributions
Community Resources
- Forums and Q&A sites
- Blogs and articles
- Videos and screencasts
- Podcasts and talks

Step 5: Define Checkpoints and Milestones

Establish clear progress markers:

Knowledge Checkpoints
- Quiz or self-assessment
- Concept understanding verification
- Time to complete
Practical Exercises
- Hands-on coding tasks
- Expected time
- Success criteria
- Difficulty level
Mini-Projects
- Build something meaningful
- Combine multiple concepts
- Realistic scenario
- Review guidelines
Milestone Assessments
- Comprehensive projects
- Demonstrate proficiency
- Clear success criteria
- Feedback mechanism

Step 6: Plan Progress Tracking

Setup mechanism for tracking:

Weekly Check-ins
- Resources completed
- Concepts mastered
- Challenges encountered
- Time spent
Skill Validation
- Self-assessment
- Quiz scores
- Project quality
- Peer review
Timeline Adjustment
- Accelerate if on track
- Extend if needed
- Adapt based on feedback
- Celebrate milestones

Learning Path Template

# [Technology] Learning Path

## Assessment

### Your Profile

- **Current Skill Level**: [Beginner/Intermediate/Advanced]
- **Learning Style**: [Hands-on/Theory/Project-based/Mix]
- **Time Available**: [X hours/week]
- **Prior Experience**: [Relevant technologies]

### Goals

- **Primary Objective**: [What you'll be able to do]
- **Target Level**: [Beginner/Intermediate/Advanced proficiency]
- **Timeline**: [X weeks]
- **Success Criteria**: [Measurable outcomes]

## Concept Sequence

### Foundation (Week 1)

**Concepts**: Core terminology, basic architecture, key principles

**Resources**:

1. [Resource Title](link) - X hour read/watch
2. [Interactive Exercise](link) - X hours hands-on
3. **Checkpoint**: Take quiz or build minimal example

### Core Functionality (Week 2-3)

**Concepts**: Main features, common patterns, real-world usage

**Resources**:

1. [Tutorial](link) - X hours
2. [Project](link) - Build working application
3. **Checkpoint**: Code review or project demo

### Advanced Topics (Week 4+)

**Concepts**: Complex scenarios, optimization, production patterns

**Resources**:

1. [Advanced Guide](link) - X hours
2. [Real Project](link) - Tackle open-source or real problem
3. **Checkpoint**: Implement advanced feature or optimization

## Progress Tracking

| Week | Topic          | Resource           | Status      | Time | Notes                |
| ---- | -------------- | ------------------ | ----------- | ---- | -------------------- |
| 1    | Foundations    | Docs + Tutorial    | In Progress | 5h   | Good grasp of basics |
| 2    | Core Feature A | Exercise + Project | Pending     | 0h   | Not started          |

## Next Steps

- Start Week 1 resources
- Join community (Discord/Forums)
- Set up development environment

Learning Path Examples

Example 1: React Learning Path (Beginner to Intermediate)

# React Learning Path - 4 Weeks

## Assessment
- **Current Level**: Intermediate JavaScript
- **Learning Style**: Hands-on with theory background
- **Time**: 10 hours/week
- **Goal**: Build production-ready React applications

## Week 1: Foundations
1. React Docs - Main Concepts (2 hours)
2. JSX fundamentals (1 hour)
3. Interactive sandbox exercises (2 hours)
4. Checkpoint: Build static component library

## Week 2: Component Lifecycle & Hooks
1. React Docs - Hooks (2 hours)
2. State management patterns (1.5 hours)
3. Build Todo app with hooks (3 hours)
4. Checkpoint: Explain useEffect cleanup

## Week 3: Advanced Patterns
1. Context API tutorial (1.5 hours)
2. Performance optimization (2 hours)
3. Build multi-page app (4 hours)
4. Checkpoint: Code performance review

## Week 4: Integration & Real Project
1. API integration patterns (1.5 hours)
2. Testing React components (1.5 hours)
3. Build real project (5 hours)
4. Checkpoint: Deploy live project

## Resources
- React.dev official docs
- React Query for data fetching
- Vitest for testing
- Project: Weather app with real API

Example 2: Docker Learning Path (Beginner)

# Docker Learning Path - 3 Weeks

## Assessment
- **Current Level**: Basic Linux command line
- **Learning Style**: Project-based
- **Time**: 8 hours/week
- **Goal**: Containerize applications, run multi-container services

## Week 1: Docker Basics
1. Docker Docs - Getting Started (1 hour)
2. Install Docker locally (0.5 hours)
3. Run and interact with containers (2 hours)
4. Dockerfile fundamentals (1 hour)
5. Checkpoint: Build Node.js app Dockerfile

## Week 2: Images and Registries
1. Docker Images deep dive (1.5 hours)
2. Docker Hub tutorial (1 hour)
3. Build and push custom image (2 hours)
4. Multi-stage builds (1 hour)
5. Checkpoint: Optimize image size

## Week 3: Docker Compose & Real App
1. Docker Compose basics (1.5 hours)
2. Multi-container application (2 hours)
3. Networking and volumes (1 hour)
4. Containerize your own project (3 hours)
5. Checkpoint: Deploy compose stack

## Resources
- Docker official documentation
- Play with Docker online sandbox
- Project: Containerize existing app

Example 3: TypeScript Learning Path (Intermediate Developer)

# TypeScript Learning Path - 6 Weeks

## Assessment
- **Current Level**: Intermediate JavaScript, familiar with types
- **Learning Style**: Theory-first with practical coding
- **Time**: 5-7 hours/week
- **Goal**: Write production TypeScript, advanced patterns

## Week 1-2: Fundamentals
- Type system basics
- Generics introduction
- Common types and patterns
- Project: Refactor JS module to TS

## Week 3-4: Advanced Features
- Advanced generics
- Conditional types
- Utility types
- Project: Build reusable utilities

## Week 5-6: Ecosystem & Real Code
- TypeScript with frameworks
- Testing typed code
- Production patterns
- Project: Full-stack TypeScript app

## Resources
- TypeScript Handbook
- Advanced Types deep dives
- Real project in your stack

Usage Examples

Example 1: Create a Learning Path from Scratch

User: I want to learn Vue.js and I have 10 hours per week.
      I know React and prefer hands-on learning.

Claude:

1. **Assessment** (clarify your situation):
   - You know React, so component model is familiar
   - Want hands-on learning
   - 10 hours/week available
   - Timeline: 4-6 weeks for intermediate proficiency

2. **Create Personalized Path**:
   - Week 1: Vue fundamentals (leverage React knowledge)
   - Week 2: Composition API (vs Options - choose best path)
   - Week 3-4: Real project
   - Week 5-6: Advanced patterns

3. **Provide Resources**:
   - Official Vue.dev documentation
   - Interactive tutorials
   - Comparison guide: Vue vs React
   - Project suggestions

4. **Setup Tracking**:
   - Weekly checkins
   - Progress dashboard
   - Milestone assessments

Example 2: Adapt Path Based on Feedback

User: I finished Week 2 of the React path but it was harder than expected.

Claude:

1. **Understand Challenge**:
   - Ask what was difficult
   - Assess understanding level
   - Identify knowledge gaps

2. **Adapt Path**:
   - Slow pace if needed
   - Add prerequisite concepts
   - Suggest alternative resources
   - Adjust timeline

3. **Provide Support**:
   - Recommend easier tutorial
   - Break down complex concept
   - Provide additional exercises
   - Schedule extra checkpoint

4. **Update Tracking**:
   - Adjust timeline
   - Add buffer weeks
   - Note learnings for future

Example 3: Multi-Technology Learning Path

User: I need to learn Kubernetes, Docker, and cloud deployment
      for an upcoming project. What's the right order?

Claude:

1. **Assess Prerequisites**:
   - Kubernetes requires Docker foundation
   - Both need Linux/container basics
   - Suggest learning order

2. **Create Integrated Path**:
   - Foundation: Linux & container concepts
   - Phase 1: Docker (3 weeks)
   - Phase 2: Kubernetes (4 weeks)
   - Phase 3: Cloud deployment (2 weeks)

3. **Show Dependencies**:
   - Docker exercises inform Kubernetes concepts
   - Real project ties everything together

4. **Total Commitment**:
   - X weeks at Y hours/week
   - Milestone dates
   - Integration points

Assessment Checklist

Path Quality Verification

Resource Quality

Progress Tracking

Clear way to track completion
Checkpoint assessments defined
Adjustment mechanism for struggles
Celebration of milestones
Community/support resources listed
Reflection mechanism built in

Key Principles

1. Personalization Over Generic

Paths adapt to individual learning style
Respect prior knowledge and background
Adjust pace based on feedback
Consider time constraints

2. Progressive Complexity

Foundation before advanced
Simple examples before real code
Theory before deep dives
Repeating concepts in new contexts

3. Multiple Resource Types

Don't rely on single format
Mix reading, video, hands-on, projects
Vary authors and perspectives
Include community knowledge

4. Measurable Progress

Clear checkpoints and milestones
Self-assessment mechanisms
Projects demonstrate learning
Tracked time investment

5. Flexibility and Adaptation

Adjust when struggling
Accelerate when ahead
Skip prerequisites if known
Pivot based on interests

Common Pitfalls to Avoid

Unrealistic Timelines: Don't compress learning into impossible timeframes
Too Many Resources: Curate quality over quantity
Skipping Fundamentals: Never skip prerequisites
No Hands-On: Theory alone doesn't build skills
Missing Checkpoints: Progress visibility matters
Ignoring Learning Style: Same path doesn't work for everyone
No Real Projects: Theory must connect to practice
Overwhelming Scope: Break into manageable pieces

Success Criteria

A successful learning path:

User completes all checkpoints
Skills are applied in real projects
User reports confidence improvement
Can teach others the concepts
Applies learning in work/personal projects
Continues learning independently
Understands when to seek advanced resources

Integration with Other Skills

Project Builder: Use created learning paths for onboarding new team members
Module Spec Generator: Document what was learned in structured format
Performance Optimizer: Identify which resources were most efficient

Advanced Features

Learning Style Adaptation

Adjust resources based on learning preference
Mix theory-first for analytical learners
Project-first for hands-on learners
Visual resources for visual thinkers

Prerequisite Chaining

Identify dependencies between topics
Skip if already known
Add depth if weak areas identified
Create customized starting point

Community Integration

Link to local meetups
Suggest Discord communities
Open-source projects to contribute to
Mentorship opportunities

Career Path Integration

Connect learning to career goals
Show progression to next level
Identify specialization options
Build portfolio through projects

learning-path-builder

$ 설치