💻 computer science

Agentic Education: Using Claude Code to Teach Claude Code

This paper introduces "cc-self-train," a modular, adaptive curriculum that teaches developers to master the agentic AI tool Claude Code through a progressive persona model, cross-domain project transfer, and auto-updating materials, demonstrating statistically significant gains in self-efficacy across 50 modules.

Original authors: Zain Naboulsi

Published 2026-04-21

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zain Naboulsi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you just bought a brand-new, incredibly powerful robot assistant that can write code, fix bugs, and build entire software projects on its own. You're excited, but when you open the manual, it's just a giant list of technical specs with no clear path on how to actually use it. You try watching random YouTube videos, but they're outdated by the time you finish them. You feel lost.

This is the problem Zain Naboulsi faced with Claude Code, a new type of AI that acts like an autonomous agent. To fix this, he built cc-self-train, a smart, interactive school designed to teach you how to master this robot.

Here is how the system works, explained through simple analogies:

1. The "Gradual Release" Teacher (The Persona Shift)

Imagine a human teacher. When you first walk into their class, they are very patient, explaining every single step and holding your hand. As you get better, they stop explaining the basics and start asking, "What do you think we should do next?" By the time you graduate, they are just sitting in the back, cheering you on while you work alone.

Most AI tutors are like a robot with a broken voice box: they stay the same "patient teacher" forever, which gets annoying for experts, or they stay too "bossy," which scares off beginners.

cc-self-train changes its personality as you learn, moving through four stages:

The Guide (Beginner): A patient teacher who explains everything.
The Collaborator (Intermediate): A work partner who asks questions before giving answers.
The Peer (Advanced): A senior colleague who gives short, direct hints and lets you figure it out.
The Launcher (Expert): A coach who says, "You've got this," and steps back completely.

2. The "Smart Watch" (Adaptive Learning)

Imagine a personal trainer who watches your workout. If you keep struggling with a specific exercise, they don't just yell "do it again"; they step in immediately to help. If you're breezing through, they don't waste your time with basic warm-ups; they give you a harder challenge.

This system does the same thing. It quietly watches how you talk to the AI.

If you say things like "Just write the code for me," it knows you're stuck and gives you more help.
If you say things like "I tried this and noticed that...", it knows you're thinking deeply and lets you go further.
It adjusts your "difficulty level" in real-time without you even knowing, so you never feel bored or overwhelmed.

3. The "Universal Remote" (Cross-Domain Transfer)

Usually, learning a tool means learning it for one specific job. If you learn to use a hammer to build a chair, you might not know how to use it to build a birdhouse.

This curriculum is like a Universal Remote. It teaches you the same 10 core skills (like how to set rules, how to use memory, how to create custom commands) but lets you apply them to five different "projects":

Building a personal website.
Making a command-line tool.
Creating a local server.
Building a code analyzer.
BYOP (Bring Your Own Project): You apply the skills to your own real work.

Because the skills are taught in the exact same order for every project, once you master the "remote," you can use it on any "TV" (any project) you want.

4. The "Pause Button" (Step-Pacing)

Imagine a teacher who tries to teach you a whole semester's worth of math in one 30-second burst. You'd be dizzy and confused. This is a common problem with AI: it can generate thousands of words instantly, overwhelming your brain.

This system has a hard "STOP" button. The AI is programmed to stop after every single step, wait for you to type "I'm ready," and then move to the next step. It forces the AI to breathe, giving your brain time to digest the information before moving on.

5. The "Self-Healing Textbook" (Auto-Updating)

Software tools change incredibly fast. A tutorial written today might be useless next week because the tool changed a feature. Traditional textbooks rot on the shelf.

This curriculum is a living, self-healing organism.

When you start the course, the AI checks: "Is the tool version you have the same as the one I was trained on?"
If the tool has updated, the AI automatically rewrites the lesson plan before you start, fetching the new rules and fixing the exercises.
It's like a textbook that rewrites its own pages every morning to match the latest news, so you never learn outdated information.

The Result?

The author tested this with 27 developers. The results were huge:

Confidence Skyrocketed: People felt much more capable of using the tool.
Big Gains for Everyone: Beginners learned the basics faster, and experts learned the complex, "magic" features (like custom automation hooks) that usually take years to figure out.

In short: This paper presents a way to teach AI tools not by giving you a static manual, but by creating a smart, evolving, interactive partner that grows with you, keeps the lessons fresh, and ensures you never get left behind.

1. Problem Statement

The rapid proliferation of agentic AI coding tools (e.g., Claude Code, OpenAI Codex) has created a significant pedagogical gap. While these tools offer autonomous capabilities (planning, file manipulation, shell execution), learning resources remain fragmented, ad-hoc, and perishable.

The Gap: Developers lack structured pathways to move from basic usage to advanced compositional mastery (e.g., hook pipelines, subagent architectures).
Content Decay: Official documentation and third-party tutorials quickly become obsolete as agentic tools ship breaking changes on a daily cadence.
Cognitive Overload: AI instructors often generate unbounded text in single responses, overwhelming learners' working memory, unlike human teachers who pace instruction.
Static Personas: Existing AI tutors typically maintain a fixed tone, failing to adapt scaffolding as the learner progresses from novice to expert.

2. Methodology: The `cc-self-train` System

The authors present cc-self-train, a modular, interactive curriculum framework designed to teach Claude Code through hands-on project construction. The system is built on five core architectural pillars:

A. Persona Progression Model (Gradual Release of Responsibility)

The system adapts the AI instructor's tone and scaffolding based on the Gradual Release of Responsibility (GRR) framework, mapped to four distinct stages:

Guide (Modules 1–3): Patient teacher; explains concepts before use, defines terms, and walks through errors.
Collaborator (Modules 4–6): Working partner; asks questions before answering, provides partial code, and encourages debugging.
Peer (Modules 7–9): Senior colleague; terse, direct, points to documentation, and expects the learner to drive.
Launcher (Module 10): Independent learning; states goals and steps back, intervening only after repeated failure.

Implementation: Personas are enforced via metadata directives in module files, dynamically adjusted based on the learner's self-reported experience and runtime performance.

B. Adaptive Learning System

To address inaccurate self-reporting of skill levels, the system employs a two-timescale adaptive loop:

Observation Layer: A Stop hook silently classifies learner interactions into six categories (e.g., concept_question, answer_seeking) using keyword heuristics. It tracks a rolling quality score and detects "streaks" (consecutive struggles or high engagement).
Fast Clock (Mid-Module): Detects struggle streaks (3+ consecutive unproductive signals) and immediately increases scaffolding depth.
Slow Clock (Module Boundary): Aggregates metrics to adjust the learner's Effective Level (e.g., promoting a "beginner" to "intermediate" persona logic if they demonstrate high conceptual understanding).
Asymmetric Principle: The system is quicker to add scaffolding for struggling learners than to withdraw it, preventing disengagement.

C. Cross-Domain Unified Curriculum

The curriculum enforces identical feature sequencing across five distinct project domains:

Canvas: Personal Portfolio (HTML/CSS/JS).
Forge: CLI Dev Toolkit.
Nexus: Local API Gateway.
Sentinel: Code Analyzer.
BYOP (Bring Your Own Project): Learners apply features to their existing codebases.

Goal: This structure ensures transfer learning; learners master the tool's capabilities (hooks, skills, MCP) independent of the specific domain context.

D. Step-Pacing and Information Load Management

To mitigate cognitive overload in terminal-based AI interactions:

STOP Blocks: Explicit pause primitives embedded in module files that force the AI to halt after a specific step, requiring learner input before proceeding.
State Tracking: Uses a persistent CLAUDE.local.md file to track current steps across session restarts and context window compaction, ensuring the AI never loses its place.

E. Auto-Updating Curriculum Design

The system solves content decay via an onboarding agent and a sync pipeline:

Detection: Upon starting, the agent checks the installed Claude Code version against the curriculum's last-synced version.
Sync Pipeline: If a version gap exists, the agent fetches the upstream changelog, maps new features to specific modules, researches them, and appends new steps to the curriculum files.
Safety: Uses a "safe-append" rule (never renumbering existing steps) and a parametrized test suite to verify structural integrity before instruction begins.

3. Key Contributions

Persona Progression Model: Operationalizes GRR for AI-mediated instruction, dynamically shifting from "I do it" to "You do it alone."
Adaptive Learning Architecture: A lightweight, hook-based system that adjusts scaffolding in real-time based on engagement quality and sequential failure patterns.
Unified Cross-Domain Curriculum: A design pattern where 5 project paths share identical feature sequencing to maximize transfer of tool mastery.
Step-Pacing Mechanism: Introduces "STOP" blocks and state persistence to manage cognitive load in unbounded AI generation contexts.
Auto-Updating Design: A self-maintaining pipeline that detects tool changes and updates teaching materials automatically before the learner begins.
Automated QA: A parametrized test suite (8 files, 50+ test cases) that enforces structural consistency and pedagogical invariants across all modules.

4. Results

A pilot study was conducted with 27 professional software engineers (9 beginners, 8 intermediate, 10 advanced).

Self-Efficacy Gains: Participants showed statistically significant improvements ( $p < 0.001$ ) across all 10 assessed skill areas.
Effect Sizes: Large effect sizes were observed, particularly for advanced features:
- Setting up hooks: $d = 2.79$
- Creating skills: $d = 2.55$
- Troubleshooting agent behavior: $d = 1.11$
Expertise Gradient: Beginners showed the largest absolute gains (+1.18 on a 5-point scale), while advanced users still improved significantly on compositional features, validating the efficacy of the experience-stratified persona boundaries.
Validation: The test suite successfully enforced structural consistency, ensuring no curriculum updates violated pedagogical invariants.

5. Significance and Implications

Pedagogical Innovation: This work demonstrates that structured, progressive pedagogy is feasible for agentic AI tools, moving beyond static documentation to dynamic, agent-driven learning.
Scalability: The auto-updating mechanism addresses the "content decay" problem inherent in rapidly evolving AI tools, ensuring curricula remain current without manual maintenance.
Generalizability: While implemented for Claude Code, the architectural patterns (persona progression, unified sequencing, step-pacing) are designed to be tool-agnostic and applicable to other agentic environments (e.g., research agents, legal AI).
Open Source: The system is open-source (MIT License), allowing for community extension, localization, and independent replication.

In conclusion, cc-self-train provides a robust framework for bridging the gap between powerful agentic tools and developer mastery, proving that AI can effectively teach itself to be used more effectively through structured, adaptive, and self-updating educational systems.