I Built a Free AI Mastery Roadmap (And Why It's Not Another $500 Course)

I wasted months learning Claude Code the hard way.

Random tutorials. Scattered docs. Trial and error. Hours spent figuring out what should've taken minutes.

So I built the roadmap I wish I'd had from day one. And I'm open-sourcing it because gatekeeping knowledge is nonsense.

What This Is (And Isn't)

This is NOT:

• Another $500 course promising mastery in 30 days


• A collection of random tips you'll forget tomorrow


• Vaporware that looks good but doesn't work


• A marketing funnel disguised as education

This IS:

• 
  24 atomic learning units you can complete in 15-30 minutes each


• 
  Structured progression from beginner to power user


• 
  Repeatable exercises you practice 3-5 times to build muscle memory


• 
  Measurable ROI - track exactly how much time you save


• 
  Completely free on GitHub

Why I Built This

I'm a solo dev building products like DevClose (daily reflection for developers) and Planr (kanban for indie hackers). I needed to get faster with AI tools or I'd burn out.

But here's the problem: Most AI courses are either:

1. Too basic (here's how to write a prompt)


2. Too advanced (assume you already know everything)


3. Too expensive (hundreds of dollars for recycled content)


4. Too long (40-hour courses nobody finishes)

I needed something different. Atomic units I could practice daily. Clear wins I could measure.

So I built it.

What's Inside

Level 1: Prompt Foundations (5 units, 2-3 hours)

Learn to write prompts Claude executes perfectly the first time.

Units:

• Clear Prompts (Action + Target + Details)


• Multi-Step Prompts (Structure complex tasks)


• Context-First Prompts (Give context before asking)


• Precision Requests (Add constraints and format)


• Core 4 Understanding (Context, Model, Prompt, Tools)

Outcome: Save 30-60 min/day on exploration

Level 2: Slash Command Mastery (7 units, 4-6 hours)

Build your personal toolkit of reusable commands.

Units:

• Understanding Commands


• Analysis Commands (examine code)


• Generator Commands (create code)


• Fix Commands (solve problems)


• Workflow Commands (chain operations)


• Command Optimization (make them better)


• Building Your Toolkit (organize 15-20 commands)

Outcome: Save 5-10 hours/week

Level 3: Feature Composition (6 units, 3-5 hours)

Combine features for powerful workflows.

Units:

• Understanding MCP (external integrations)


• Commands with MCP


• Understanding Sub Agents (parallel workers)


• Parallel Sub Agents (multiple simultaneously)


• Composing Commands (commands calling commands)


• Advanced Workflows (MCP + Agents + Commands)

Outcome: Save 10-15 hours/week

Level 4: Autonomous Skills (6 units, 4-6 hours)

Create skills that work automatically.

Units:

• Understanding Skills (when to build them)


• First Simple Skill


• Adding Resources (examples/templates)


• Composing in Skills (orchestrate features)


• Meta-Skills (skills that build skills)


• Advanced Patterns (context-aware, adaptive)

Outcome: Save 15-25 hours/week

The Repetition Method

Here's what makes this different: Each unit is designed to be completed 3-5 times.

Completion 1: Learn the concept, complete basic exercises

Completion 2: Apply to different scenario, refine understanding

Completion 3: Master the technique, build muscle memory

Completion 4-5: Solidify with complex practice

Why? Because reading isn't learning. Practice is learning. Repetition is mastery.

The ROI

Let's talk numbers.

Total Time Investment:

• 13-20 hours of practice (spread over 8-12 weeks)


• 30 minutes per day of deliberate practice

Time Saved Weekly:

• After Level 1: 2-4 hours/week


• After Level 2: 5-10 hours/week


• After Level 3: 10-15 hours/week


• After Level 4: 15-25 hours/week

Break-Even Point:

• Week 4: Net positive (saved more than invested)


• Week 8: 60-100 hours saved


• Month 3: 180-300 hours saved


• Year 1: 780-1300 hours saved = 19-32 weeks of work

That's half a year of your life back.

What Each Unit Includes

Every unit has the same structure:

1. 
   Learn Section (5 min): Core concept, why it matters, examples


2. 
   Practice Section (15 min): Hands-on exercises, real-world application


3. 
   Repeat Instructions: How many times, what to vary, progressive difficulty


4. 
   Success Checklist: Clear completion criteria before moving on


5. 
   Time Savings: Estimated ROI for this specific skill


6. 
   Personal Notes: Track each completion, record learnings

No fluff. No filler. Just actionable practice.

Why It's Free

Three reasons:

1. I Needed It Anyway

I built this for myself first. The marginal cost of sharing it is zero.

2. Anti-Gatekeeping Philosophy

Knowledge compounds when shared. If 100 people become power users, they'll create things that make the ecosystem better for everyone.

3. Teaching Sharpens the Teacher

Writing these units forced me to crystallize my understanding. The best way to learn is to teach.

Plus, honestly? The market is saturated with expensive AI courses. I'm not competing with them. I'm building in public and helping people learn.

Who This Is For

You should use this if:

• You're new to Claude Code and want structured learning


• You've used it a bit but feel inefficient


• You have scattered knowledge and want to systematize it


• You learn by doing (not just reading/watching)


• You want measurable improvements (time saved)

Skip this if:

• You're already a Claude Code power user


• You prefer video tutorials over text exercises


• You won't commit to repetition (each unit 3-5 times)


• You want someone to hold your hand (this is self-directed)

What Makes It Different

Atomic Units

One focused skill per file. Master it before moving on.

Repeatable

Practice 3-5 times to build muscle memory and confidence.

Progressive

Each unit builds on previous ones. No random jumping around.

Measurable

Track time saved. See ROI in real numbers, not vague promises.

Open Source

Fork it. Customize it. Add units for your team. It's yours.

Getting Started

If You Have 20 Minutes Right Now

1. Clone the repo: git clone https://github.com/jgerton/ai-mastery-roadmap
   


2. Open level-1-prompts/01-clear-prompts.md
   


3. Complete the practice exercise


4. Mark it in progress-tracker.md
   

You've started your journey.

If You're Committed to Mastery

1. Schedule 30 min daily for practice


2. Complete 1-2 units per day


3. Repeat each unit 3 times before moving on


4. In 8 weeks, you'll be a power user

What You'll Build

By the end of the roadmap, you'll have:

• 
  15-20 custom slash commands for your daily workflow


• 
  3-5 autonomous skills that work automatically


• 
  Complex workflows combining MCP + sub agents + commands


• 
  15-25 hours saved per week (measured, not guessed)

And most importantly: Confidence. You'll know you can tackle any task efficiently.

The Learning Path

Week 1-2:   Level 1 (Prompts)          → Save 2-4 hrs/week

Week 3-4:   Level 2 (Commands)         → Save 5-10 hrs/week

Week 5-6:   Level 3 (Composition)      → Save 10-15 hrs/week

Week 7-8:   Level 4 (Skills)           → Save 15-25 hrs/week



Total: 8 weeks | 13-20 hours invested | 780-1300 hours saved/year

Common Questions

Q: Do I need to be a developer?

A: No. If you use Claude Code, this will help. The examples are code-focused, but the principles apply to any use case.

Q: Can I skip units?

A: You can, but you shouldn't. Each builds on previous ones. Skipping creates gaps.

Q: How long does it really take?

A: 13-20 hours total practice. Spread over 8-12 weeks (30 min/day), or faster if you have more time.

Q: Is this beginner-friendly?

A: Yes. Level 1 assumes zero Claude Code knowledge. Start at Unit 01.

Q: What if I get stuck?

A: Each unit has troubleshooting tips. Repeat the previous unit. Try simpler examples. Take a break.

Q: Can I use this with my team?

A: Absolutely. Fork the repo. Customize units for your domain. Build a shared command library.

Q: Will you keep updating it?

A: Yes. As I learn new patterns, I'll add units. Watch the repo for updates.

What's Next for the Roadmap

I'm considering adding:

• 
  Domain-specific units (data analysis, web dev, DevOps)


• 
  Video walkthroughs for each unit


• 
  Community showcase of commands/skills people build


• 
  Team learning mode with shared progress tracking

But for now, 24 units is enough to get anyone from zero to power user.

My Ask

If this roadmap helps you:

1. ⭐ Star the repo (helps others find it)


2. 🐛 Open issues for errors or unclear instructions


3. 💬 Share feedback on what worked (or didn't)


4. 🔗 Share it with someone who'd benefit

I'm not asking for money. I'm asking for you to use it and share it if it works.

Final Thoughts

Most people never master their tools. They stay comfortable with the basics and wonder why everything takes so long.

This roadmap is for people who want their time back.

It's not flashy. It's not a course with a slick landing page and testimonials. It's just 24 markdown files that will make you faster if you put in the work.

I built it for me. I'm sharing it for you.

Start here: https://github.com/jgerton/ai-mastery-roadmap

Your first unit: level-1-prompts/01-clear-prompts.md

See you on the other side. 🚀

Jon Gerton is a solo dev building DevClose (daily reflection for developers), Planr (kanban for indie hackers), Ember Feed (personalized feed aggregation with ranking and analytics). He's based in Alaska and believes in building in public, anti-gatekeeping, and getting your time back.

Connect: @jgerton on Twitter | [email protected]