Paper deep dive

Agentic Education: Using Claude Code to Teach Claude Code

Zain Naboulsi

Year: 2026Venue: arXiv preprintArea: cs.CYType: PreprintEmbeddings: 78

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%

Last extracted: 4/27/2026, 7:43:52 AM

Summary

The paper presents 'cc-self-train', a modular, interactive, and auto-updating curriculum designed to teach 'Claude Code', an agentic AI coding tool. The system utilizes a 'Persona Progression Model' based on the Gradual Release of Responsibility (GRR) framework, transitioning the AI instructor through four stages: Guide, Collaborator, Peer, and Launcher. It features an adaptive learning system that monitors engagement via heuristics, a cross-domain unified curriculum across five project paths (Canvas, Forge, Nexus, Sentinel, BYOP), and a step-pacing mechanism to prevent cognitive overload. A pilot study with 27 participants demonstrated significant gains in self-efficacy across 10 skill areas.

Entities (15)

BYOP · project-domain · 100%Canvas · project-domain · 100%cc-self-train · systemframework · 100%Claude Code · ai-tool · 100%Collaborator · persona-stage · 100%Forge · project-domain · 100%Gradual Release of Responsibility · educational-framework · 100%Guide · persona-stage · 100%Launcher · persona-stage · 100%Nexus · project-domain · 100%Peer · persona-stage · 100%Persona Progression Model · pedagogical-model · 100%Sentinel · project-domain · 100%Sparq · organization · 100%Zain Naboulsi · person · 100%

Relation Signals (5)

Canvas → ispartof → cc-self-train

confidence 100% · The curriculum currently comprises 50 module files organized as 10 progressive modules across 5 project domains.

Guide → isstageof → Persona Progression Model

confidence 100% · adapts instructor tone across four stages (Guide, Collaborator, Peer, Launcher)

Persona Progression Model → operationalizes → Gradual Release of Responsibility

confidence 100% · operationalizing Gradual Release of Responsibility for AI-mediated instruction

cc-self-train → teaches → Claude Code

confidence 100% · We present cc-self-train, a modular interactive curriculum for learning Claude Code

Zain Naboulsi → worksat → Sparq

confidence 100% · Zain Naboulsi Principal AI Engineer, Sparq

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:AI coding assistants have proliferated rapidly, yet structured pedagogical frameworks for learning these tools remain scarce. Developers face a gap between tool documentation and practical mastery, relying on fragmented resources such as blog posts, video tutorials, and trial-and-error. We present cc-self-train, a modular interactive curriculum for learning Claude Code, an agentic AI coding tool, through hands-on project construction. The system introduces five contributions: (1) a persona progression model that adapts instructor tone across four stages (Guide, Collaborator, Peer, Launcher), operationalizing Gradual Release of Responsibility for AI-mediated instruction; (2) an adaptive learning system that observes engagement quality through hook-based heuristics and adjusts scaffolding at two timescales, using streak detection for mid-module intervention and aggregate metrics for module-boundary persona changes; (3) a cross-domain unified curriculum in which five distinct project domains share identical feature sequencing, enabling transfer learning; (4) a step-pacing mechanism with explicit pause primitives to manage information overload in an AI-as-instructor context; and (5) an auto-updating curriculum design in which the onboarding agent detects upstream tool changes and updates teaching materials before instruction begins. A parametrized test suite enforces structural consistency as a proxy for pedagogical invariants across all 50 modules. A pilot evaluation with 27 participants shows statistically significant reported self-efficacy gains across all 10 assessed skill areas (p < 0.001), with the largest effects on advanced features such as hooks and custom skills. We discuss implications for the design of auto-updating educational systems.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

77,714 characters extracted from source content.

Expand or collapse full text

Agentic Education: Using Claude Code to Teach Claude Code Zain Naboulsi Principal AI Engineer, Sparq zain.naboulsi@teamsparq.com AI coding assistants have proliferated rapidly, yet structured pedagogical frameworks for learning these tools remain scarce. Developers face a gap between tool documentation and practical mastery, relying on fragmented resources such as blog posts, video tutorials, and trial-and-error. We present c-self-train, a modular interactive curriculum for learning Claude Code, an agentic AI coding tool, through hands-on project construction. The system introduces five contributions: (1) a persona progression model that adapts the AI instructor’s tone and scaffolding across four stages (Guide → Collaborator → Peer → Launcher), operationalizing the Gradual Release of Responsibility framework for AI-mediated instruction; (2) an adaptive learning system that observes engagement quality through hook-based heuristics and adjusts scaffolding at two timescales: streak detection triggers mid-module intervention while aggregate metrics adjust persona schedules at module boundaries, grounded in evidence that engagement quality mediates AI-tutoring gains (Chung et al., 2025) and that sequential failure patterns carry higher informational weight than isolated events (Hooshyar et al., 2026); (3) a cross-domain unified curriculum in which five distinct project domains share identical feature sequencing, enabling transfer learning; (4) a step-pacing mechanism with explicit pause primitives to manage information overload in an AI-as-instructor context; and (5) an auto-updating curriculum design in which the onboarding agent detects upstream tool changes and updates teaching materials before instruction begins. A parametrized test suite enforces structural consistency as a proxy for pedagogical invariants across all 50 modules. A pilot evaluation with 27 participants shows statistically significant reported self-efficacy gains across all 10 assessed skill areas (p<0.001p<0.001), with the largest effects on advanced features such as hooks and custom skills. We describe the system architecture, analyze each contribution through established pedagogical and AI agent design lenses, and discuss implications for the design of auto-updating educational systems. https://github.com/zainnab-sparq/c-self-train Sparq Keywords: AI coding assistants, Claude Code, curriculum design, prompt engineering, auto-updating curricula, gradual release of responsibility, adaptive learning, agentic coding tools, self-efficacy 1 Introduction The landscape of AI coding tools has expanded across several distinct categories in a short span. Early tools like Tabnine and Kite offered AI-powered code completion using smaller models, and GitHub Copilot (GitHub, 2022; Chen et al., 2021) brought LLM-based completion to mainstream adoption. Cursor (Cursor, Inc., 2024) extended this with codebase-aware context and chat-based interaction within a full IDE. More recently, agentic coding tools such as Claude Code (Anthropic, 2025a) and OpenAI Codex (OpenAI, 2025) introduced a different paradigm: they operate autonomously in terminal or cloud environments, planning multi-step tasks, executing shell commands, reading and writing files, and iterating on their own output (Wang et al., 2024). These categories are converging, with Copilot adding agent mode and Cursor gaining agentic capabilities, making the need for pedagogical frameworks for agentic tools increasingly broad. Developers face a widening gap between the availability of powerful AI agents and the learning pathways needed to use them effectively. The prevailing approach to learning AI coding tools is ad hoc and, critically, perishable. Official documentation describes features in isolation without progressive learning paths. Video tutorials and blog posts cover narrow use cases but date quickly. Agentic tools ship breaking changes on a rapid cadence measured in days. We observed nominally current third-party tutorials referencing deprecated or modified features within days of publication. Even vendor-produced training courses, including Anthropic’s own course catalog (Anthropic, 2025b), can lag behind the tool’s shipping pace, leaving learners to reconcile instructional materials with a product that has already moved on. None of these resources provides a progressive, hands-on curriculum that takes a developer from first contact through advanced multi-agent orchestration, and none addresses the content decay problem inherent in rapidly evolving tooling. This gap likely limits adoption of features that require compositional understanding, such as hook pipelines, skill systems, and subagent architectures. We present c-self-train, a curriculum framework designed to address this gap. While the current implementation targets Claude Code, a terminal-based agentic coding tool, the underlying pedagogical architecture (persona progression, unified curricula, step-pacing, and auto-updating design) is designed to generalize to any agentic environment, whether the tool is a coding assistant, a research agent, or a domain-specific AI workflow, and whether it operates in a terminal, an IDE, or the cloud. The curriculum currently comprises 50 module files organized as 10 progressive modules across 5 project domains. Rather than describing features abstractly, each module teaches Claude Code capabilities through the construction of a real software project, such as a portfolio website, a CLI toolkit, an API gateway, a code analyzer, or the learner’s own existing project. While the curriculum provides sequenced scaffolding, controlling what is taught and when, the actual learning experience is exploratory and agent-driven. The learner is not clicking through slides or following a fixed script; they are conversing with an AI agent that responds to their specific project, questions, and mistakes, making each path through the material unique. The curriculum’s pedagogical design draws on the author’s 18 years of experience as a Microsoft Certified Trainer. The curriculum is designed to stay current: when a learner begins, the onboarding agent checks whether its teaching materials match the learner’s installed tool version and updates them if needed. This addresses the content decay problem at the point of use rather than relying on manual maintenance cycles. Contributions. This paper makes the following contributions: 1. A persona progression model (Section 4) that adapts instructor tone and scaffolding across four stages, mapping the Gradual Release of Responsibility (GRR) framework (Fisher and Frey, 2013) to AI-mediated instruction. 2. An adaptive learning system (Section 5) that observes learner engagement quality through hook-based heuristics and adjusts scaffolding at two timescales: streak detection for mid-module intervention and aggregate metrics for module-boundary persona changes. The design is grounded in evidence that engagement quality mediates AI-tutoring gains (Chung et al., 2025) and that non-mastery signals carry higher gradient sensitivity than mastery signals in learner models (Hooshyar et al., 2026). 3. A cross-domain unified curriculum (Section 6) that enforces identical feature sequencing across five project domains, designed to enable domain-independent transfer of tool mastery. 4. A step-pacing mechanism (Section 7) with explicit pause primitives and cross-session state tracking, addressing the information overload problem characteristic of AI-as-instructor contexts. 5. An auto-updating curriculum design (Section 9) in which the onboarding agent detects upstream tool changes and updates teaching materials before instruction begins. A parametrized test suite (Section 8) enforces structural consistency as a proxy for pedagogical invariants across all 50 modules, serving as the quality assurance layer for the above contributions. A pilot evaluation (Section 10) with 27 participants provides initial empirical evidence that the curriculum produces significant reported self-efficacy gains across all assessed skill areas. 2 Background and Related Work 2.1 AI Coding Assistants AI coding tools exist on a spectrum of autonomy, and the boundaries between categories are blurring rapidly. Completion and chat assistants. Early AI code completion tools such as Tabnine and Kite used smaller models to offer inline suggestions. GitHub Copilot (GitHub, 2022; Chen et al., 2021) brought LLM-based completion to mainstream adoption, and Cursor (Cursor, Inc., 2024) extended this with codebase-aware context and chat-based interaction within a full IDE. In their original form, these tools augment the developer’s existing workflow: the human remains the driver, and the AI provides suggestions within the editor. Agentic coding tools. Claude Code (Anthropic, 2025a) and OpenAI Codex (OpenAI, 2025) shifted the developer’s role from driver to reviewer. These tools operate autonomously, planning multi-step tasks, executing shell commands, reading and writing files, managing git workflows, and iterating on their own output. Claude Code exposes an extensible architecture of hooks, skills, subagents, MCP servers, and evaluation frameworks that compose into complex workflows. Convergence. These categories are converging: Copilot has added agent mode with autonomous multi-file editing and terminal access; Cursor has evolved from a chat-based assistant to a full agentic coding environment; and a growing number of IDEs, including Amazon Kiro and Google’s Antigravity, are shipping agentic capabilities as core features. As agentic features become standard across tools, the need for pedagogical frameworks that teach compositional tool mastery grows correspondingly. An agentic system with dozens of interacting features cannot be learned through casual use alone, regardless of whether it runs in a terminal, an IDE, or the cloud. Our curriculum framework addresses this need; the current implementation targets Claude Code, but the pedagogical architecture is designed to be tool-agnostic. 2.2 Developer Education for AI Tools Developer education for AI coding tools exists primarily in three forms: official documentation, informal tutorials, and structured courses. Official documentation usually describes features in isolation without progressive learning paths. YouTube tutorials and blog posts tend to cover narrow use cases (“How to use Copilot for X”) without building compositional understanding. Bootcamps and workshops often focus on prompt engineering (White et al., 2023) rather than tool-specific mastery. Becker et al. (2023) and Kazemitabaar et al. (2023) study how AI code generators affect programming education, but focus on learner outcomes with code completion rather than curricula for tool mastery. Prather et al. (2024) find that generative AI compounds existing metacognitive difficulties for struggling novice programmers, widening rather than closing the skill gap, motivating the need for structured learning pathways. Recent systems have begun embedding pedagogical guardrails directly into AI coding assistants: CodeAid (Kazemitabaar et al., 2024) deploys an LLM-based assistant that provides conceptual explanations and pseudocode rather than direct solutions, demonstrating that pedagogical constraints can be designed into AI tool interactions, though the focus remains on teaching programming, not on teaching mastery of an AI tool itself. A recent scoping review of 52 studies characterizes the emerging field of LLM-based pedagogical agents along four design dimensions: interaction approach (reactive vs. proactive), domain scope (specific vs. general), role complexity (single vs. multi-role), and system integration (standalone vs. integrated) (Li and Zheng, 2026). Within this taxonomy, c-self-train is a hybrid interaction agent (reactive to student-initiated code work, proactive through engagement observation and streak detection), domain-specific (targeting Claude Code mastery), multi-role (the persona transitions across four GRR stages), and integrated (hooking into the runtime it teaches). The reviewed literature covers agents that teach external subjects: science, language, general programming concepts. Vendor-produced interactive onboarding touches on host-tool usage, but to our knowledge no prior LLM-based pedagogical agent adopts a staged-persona GRR curriculum for teaching its own host tool. This reflexive design, where the tool being learned is simultaneously the pedagogical medium, is the positioning gap c-self-train fills. A complementary line of work has emerged in the open-source community. Everything Claude Code (Affaan, 2025) provides a production-oriented configuration system comprising 16 specialized agents, 65+ skills, and 40+ commands that encode best practices for working with Claude Code effectively. OpenClaw (OpenClaw Contributors, 2025) takes a broader approach, offering an open-source personal AI assistant platform with extensible skills and multi-channel integration. Superpowers (Vincent, 2025) provides a structured workflow framework (brainstorming, planning, TDD, code review) that runs across multiple agentic tools, including Claude Code, Cursor, Codex, and Gemini CLI, demonstrating that structured agentic skill frameworks can be tool-agnostic. These projects collectively demonstrate the community demand for structured approaches to AI tool mastery and influenced the design of c-self-train. Where Everything Claude Code and Superpowers optimize expert workflows and OpenClaw provides a general-purpose agent framework, our work focuses specifically on the pedagogical dimension: progressive skill acquisition through a structured curriculum with adaptive instruction. 2.3 Pedagogical Foundations Our design draws on four established frameworks: Bloom’s Taxonomy. The revised taxonomy (Bloom et al., 1956; Anderson and Krathwohl, 2001) provides a progression from remembering through creating (Figure 1). Our 10-module sequence aligns with this progression: early modules emphasize understanding and applying Claude Code features, while later modules require analyzing, evaluating, and creating novel configurations. Figure 1: Bloom’s revised taxonomy (Anderson and Krathwohl, 2001). Cognitive complexity increases from lower-order skills (remembering, understanding) to higher-order skills (evaluating, creating). Our module sequence follows this progression, with early modules at the base and the capstone module at the apex. Gradual Release of Responsibility (GRR). Fisher and Frey’s framework (Fisher and Frey, 2013) describes a four-phase instructional model: focused instruction (“I do it”), guided instruction (“We do it”), collaborative learning (“You do it together”), and independent learning (“You do it alone”). Our persona progression (Guide → Collaborator → Peer → Launcher) is an adaptation of GRR for single-learner AI-mediated instruction, mapping 1:1 to its four phases. Guide corresponds to “focused instruction” (“I do it”): the AI provides information about what the learner will encounter and models how features work, though in our context the learner is always hands-on rather than passively observing. Collaborator maps to “guided instruction” (“We do it”), where the AI scaffolds without dictating. Peer maps to “collaborative learning” (“You do it together”), reinterpreted for a single-learner context: the AI adopts an equal-footing stance rather than facilitating peer group work. Launcher maps to “independent learning” (“You do it alone”). To our knowledge, this adaptation has not been previously applied to agentic tool instruction. This progression parallels the four-level agency model proposed by Yan (2025), which describes AI roles escalating from adaptive instrument through proactive assistant and co-learner to peer collaborator, though their APCP framework addresses general human-AI collaboration rather than structured instruction. Figure 2 illustrates the framework and its mapping to our persona stages. Cognitive Load Theory. Sweller’s framework (Sweller, 1988) distinguishes intrinsic, extraneous, and germane cognitive load. Recent neuroscience evidence underscores this concern: Kosmyna et al. (2025) found that unstructured AI assistance during writing tasks led to measurable cognitive debt, with users developing weaker neural engagement patterns over repeated sessions. Our step-pacing mechanism is designed to address the unique challenge that AI instructors, unlike human teachers, can generate unbounded volumes of instruction in a single response, risking extraneous load that may overwhelm working memory. Constructionism. Papert’s constructionism (Papert, 1980) holds that learning is most effective when learners construct personally meaningful artifacts. Each of our five project options produces a functional software artifact (not a disposable exercise) that the learner retains and can extend after completing the curriculum. Figure 2: The Gradual Release of Responsibility framework (Fisher and Frey, 2013). Teacher responsibility decreases (top to bottom) as student responsibility increases across four phases: focused instruction, guided instruction, collaborative learning, and independent learning. 2.4 Auto-Updating Systems The concept of systems that monitor and improve their own outputs has gained traction in LLM research. Reflexion (Shinn et al., 2023) introduces verbal reinforcement learning, where agents reflect on task feedback to improve subsequent attempts. Self-Refine (Madaan et al., 2023) demonstrates iterative self-improvement through self-generated feedback. Our sync pipeline (Section 9) applies a related principle to educational content: the onboarding agent detects upstream releases, updates teaching steps, and verifies structural integrity before the learner begins instruction. 3 System Architecture 3.1 Repository Structure c-self-train is organized as a single Git repository with the structure shown in Figure 3. The repository comprises: • 5 project directories (projects/canvas, forge, nexus, sentinel, byop), each containing 10 module files and a project-specific README. • 22 context documents (context/) providing reference material for every Claude Code feature. • Configuration files (.claude/) including the onboarding skill (/start), session hooks, adaptive learning observation and context-injection scripts, and sync pipeline. • 8 test files (tests/) with parametrized test suites. • A workspace directory (workspace/, gitignored) where learner projects are scaffolded. c-self-train/.claude/configCLAUDE.mdconventionsREADME.mdoverviewcontext/22 docstests/8 suitesCanvasForgeNexusSentinelBYOP10 Modules per PathM1M2M3M4M5M6M7M8M9M10 Guide Collaborator Peer Launcher Figure 3: System architecture of c-self-train. Five project paths share 10 modules with identical feature sequencing. Module colors indicate persona stage. The .claude/ directory contains onboarding skills, session hooks, adaptive learning scripts, and the curriculum sync pipeline. The 22 context documents serve as reference material read by Claude Code during instruction. 3.2 The Five Learning Paths Each path produces a different software artifact while teaching the same 10 Claude Code feature sets in the same order: 1. Canvas (Personal Portfolio Site): HTML/CSS/JS with no build tools. Recommended for first-time users due to zero toolchain friction. 2. Forge (Personal Dev Toolkit): A CLI tool for notes, snippets, and templates. Language-agnostic. 3. Nexus (Local API Gateway): A local server with routing, rate limiting, and caching. Language-agnostic. 4. Sentinel (Code Analyzer & Test Generator): A static analysis tool with auto-generated tests. Language-agnostic. 5. BYOP (Bring Your Own Project): Learners apply the curriculum to an existing codebase, providing the ultimate transfer test. Canvas uses HTML/CSS/JS to eliminate toolchain setup. Forge, Nexus, and Sentinel span CLI tools, backend services, and developer tooling, respectively, allowing learners to choose based on interest rather than difficulty. BYOP, added in v2.12.0, tests whether learners can generalize Claude Code mastery to arbitrary codebases. 3.3 Module Sequencing and Feature Dependencies The 10 modules follow a strict dependency order that builds compositional understanding (Table 1). Each module assumes mastery of all prior modules. The sequencing reflects a mix of technical dependencies and conceptual prerequisites: guard rails (Module 7) extend the hook infrastructure introduced in Module 5; subagents (Module 8) reuse the Markdown-with-frontmatter conventions introduced with skills (Module 4); hooks (Module 5) are configured within the same .claude/ directory structure introduced in Module 3; and the capstone module (10) integrates all prior features. Table 1: The 10-module curriculum with Claude Code features and teaching persona (intermediate schedule shown; beginners and advanced learners follow different persona boundaries, see Section 4). # Module C Features (selected) Persona 1 Setup & First Contact CLAUDE.md, /init, /memory, interactive mode, keyboard shortcuts Guide 2 Blueprint & Build Plan mode, git integration, basic prompting, model selection Guide 3 Rules, Memory & Context .claude/rules/, CLAUDE.local.md, @imports, /context, /compact Guide 4 Skills & Commands SKILL.md, frontmatter, custom commands, hot-reload, argument substitution Collaborator 5 Hooks SessionStart, PostToolUse, Stop hooks, matchers, hook scripting Collaborator 6 MCP Servers MCP servers, .mcp.json, scopes, skills + MCP integration Collaborator 7 Guard Rails PreToolUse, hook decision control, prompt-based hooks Peer 8 Subagents .claude/agents/, subagent frontmatter, chaining, parallel, background Peer 9 Tasks & TDD Tasks system, dependencies, cross-session persistence, TDD loops Peer 10 Parallel Dev & Eval Worktrees, agent teams, plugins, evaluation framework, continuous learning Launcher 3.4 Onboarding as State Machine The entry point is the /start skill, a multi-step onboarding flow implemented as a state machine with resume capability. The flow proceeds through: curriculum version check → project selection → curriculum upgrade (if a newer release was detected) → OS detection → language selection (skipped for Canvas/BYOP) → experience level → progress resume (if prior state exists) → environment verification and tool installation → project scaffolding → Module 1 delivery. The resume check is deliberately placed after project and experience selection so that the system can validate prior state against the learner’s current choices. The curriculum step operates in two phases: a quick version comparison before project selection, followed by the full sync pipeline (fetch changelog, triage changes, update module and context files) after project selection, since the sync needs to know which project path the learner chose. Each state is persisted to .claude/onboarding-state.json, enabling the onboarding to survive session interruptions, context compaction events, and even terminal crashes. This design decision arose from observed failure modes during early testing where learners would lose progress mid-onboarding. 4 Persona Progression Model The persona progression model addresses a recurring mismatch in AI-mediated instruction: a static tone either underwhelms beginners or patronizes experts. 4.1 Design Rationale Human instructors naturally shift their communication style as content becomes more advanced. Early lessons receive patient explanations; advanced topics receive terse pointers to relevant literature. This shift supports engagement across the learning trajectory. However, AI assistants typically operate with a fixed persona regardless of content stage. The persona progression model explicitly encodes this shift, tying instructional tone to module position in the sequence. 4.2 The Four Stages The curriculum defines four personas, each specified as a prompt engineering directive in every module file (Figure 4): GuideModules 1–3Patient teacher.Explains everyconcept first.CollaboratorModules 4–6Working partner.Asks beforetelling.PeerModules 7–9Senior colleague.Terse, direct.Points to docs.LauncherModule 10Letting go.States goal,steps back. “Let’s try…” “Here’s what that does…” “What if we…” “Try this and tell me…” “Your call” “What would you do here?” “You’ve got this” “Go build it.” I do itWe do itYou do it togetherYou do it alone Figure 4: The four-stage persona progression with example phrases and mapping to the Gradual Release of Responsibility (GRR) framework (Fisher and Frey, 2013). In our adaptation, “I do it” is reinterpreted: the AI models and explains while the learner executes, rather than the learner passively observing. Module ranges shown are for the intermediate schedule; beginners and advanced learners follow different boundaries (see Section 4). Stage 1: Guide (Modules 1–3). The AI acts as a patient teacher. Every concept is explained before the learner is asked to use it. Technical terms are defined on first use. Small successes are acknowledged (“Nice, you just created your first rule file!”). When errors occur, the AI walks through the fix step by step. This stage corresponds to GRR’s “focused instruction” phase (“I do it”): the AI provides information and models how features work, though the learner is always hands-on rather than passively observing. The learner is building foundational vocabulary and mental models for the tool’s configuration system, git integration, and rule hierarchy. Stage 2: Collaborator (Modules 4–6). The AI shifts to a working partner. Basic concepts (git, CLAUDE.md, rules) are no longer re-explained. The AI asks questions before providing answers (“What do you think this hook should trigger on?”). Code examples become less complete, replaced by pointers (“The skill needs a frontmatter block. Check the docs if you need the format”). When errors occur, the AI asks “What do you see in the error?” before stepping in. This corresponds to GRR’s “guided instruction” phase (“We do it”), where the AI scaffolds experiences without dictating what to think. Stage 3: Peer (Modules 7–9). The AI adopts a senior colleague’s manner. Guidance is terse and direct. Rather than inline explanations, the AI points to reference files (“Check context/hooks.txt for the full event list”). Debugging is learner-driven; the AI intervenes only after the learner has attempted a fix. Challenges replace instructions: “Can you wire this up without me spelling it out?” This maps to GRR’s “collaborative learning” phase (“You do it together”), reinterpreted for a single-learner context: the AI acts as an equal-footing partner rather than facilitating peer group work. Stage 4: Launcher (Module 10). The AI states the goal and steps back. Intervention occurs only after multiple failed attempts. Framing emphasizes the learner’s existing competence: “You already know how to do this.” The final module ends with genuine recognition of mastery. This is GRR’s “independent learning” phase. 4.3 Implementation Each module file contains an explicit persona directive as a metadata line: ⬇ **Persona -- Peer:** Terse guidance, point to docs, let them debug first. "Your call", "What would you do here?" This line is consumed by Claude Code when reading the module file, shaping the tone and scaffolding depth of all subsequent responses within that module. A single line of natural language prompt engineering replaces what could otherwise be a more elaborate programmatic system. Persona adaptation works through descriptive prompt directives alone, without fine-tuning, RLHF, or RAG. The persona boundaries are initially set at onboarding based on declared experience level, selecting from three schedules: beginners receive extended scaffolding (4/3/2/1 Guide/Collaborator/Peer/Launcher modules), intermediate learners follow the baseline progression (3/3/3/1), and advanced users reach peer-level autonomy earlier (1/3/5/1). However, these boundaries are not permanently fixed. The adaptive learning system (Section 5) observes engagement quality during instruction and adjusts the learner’s Effective Level at module boundaries, allowing the persona schedule to shift dynamically based on observed behavior. A second, orthogonal dimension controls explanation depth within whatever persona is active: instructions written to CLAUDE.local.md during onboarding determine how much background context accompanies each response. A beginner in Module 7 still receives the Peer tone but gets more thorough explanations of underlying concepts; an advanced user in Module 1 still receives the Guide tone but skips basic tool definitions. The persona governs how much hand-holding; the experience level (and its runtime-adjusted Effective Level) governs both which persona is active and how much background is provided. 4.4 Validation The persona specification is enforced by automated tests. The TestAdaptivePersonaTable class in tests/test_modules.py verifies that experience-level persona boundaries cover all 10 modules without gaps and that personas never regress. A separate TestPersonaProgression class validates that each module file contains the correct persona directive for the intermediate schedule: ⬇ ADAPTIVE_MAP = "beginner": "Guide": range(1,5), "Collaborator": range(5,8), "Peer": range(8,10), "Launcher": range(10,11), "intermediate": "Guide": range(1,4), "Collaborator": range(4,7), "Peer": range(7,10), "Launcher": range(10,11), "advanced": "Guide": range(1,2), "Collaborator": range(2,5), "Peer": range(5,10), "Launcher": range(10,11), The test suite parametrically verifies that every experience level covers all 10 modules without gaps, that personas never regress, and that module-file defaults match the intermediate schedule. This ensures that curriculum updates, including those made by the automated sync pipeline, cannot accidentally violate the persona progression for any experience level. 5 Adaptive Learning System The persona schedules described in Section 4 adapt scaffolding across the curriculum, but the schedule is selected once at onboarding based on self-reported experience. Self-reports can be inaccurate: a developer who has used GitHub Copilot extensively may overestimate their readiness for an agentic tool, while a newcomer with strong software engineering fundamentals may underestimate theirs. A recent randomized controlled trial with 770 high school students found that adaptive problem sequencing improved exam performance by 0.15 standard deviations (p<0.05p<0.05), equivalent to 6–9 months of additional schooling (Chung et al., 2025). The key finding: gains were almost entirely mediated by increased engagement quality, not harder problems or more problems. Beginners benefited most (0.215 SD); experienced students saw negligible effect. This motivated a lightweight observation layer that tracks engagement quality and feeds back into persona selection. 5.1 Three-Layer Architecture The adaptive learning system operates through three layers, each implemented as a Claude Code hook or instruction set. Layer 1: Observation. A Stop hook (observe-interaction.js) fires silently after every Claude response. It reads the student’s most recent message from the conversation transcript and classifies it into one of six engagement categories using keyword heuristics (Table 2). Each category carries a quality score from 1 to 5. Scores accumulate in a local file (learner-profile.json, gitignored) that tracks both lifetime and per-module interaction counts, a rolling quality average, and a trend indicator (improving, stable, or declining) computed by comparing recent scores against preceding ones. In addition to aggregate statistics, the script maintains a sliding window of the last five non-neutral categories and computes two streak booleans: struggleStreak (three or more consecutive answer_seeking or passive_acceptance classifications) and engagementStreak (three or more consecutive concept_question or independent_exploration classifications). This streak detection is motivated by research showing that non-mastery rules (repeated incorrect responses) carry higher gradient sensitivity than mastery rules in neural-symbolic knowledge tracing models, meaning sequential failure patterns are more informative than isolated events (Hooshyar et al., 2026). The script is silent (no output to the student), adds negligible latency, and uses a filesystem lock to prevent re-entrancy. Table 2: Engagement categories used by the observation hook. Quality scores range from 1 (unproductive) to 5 (highly productive). Category Type Score Example Signals concept_question Productive 5 “why does…”, “how does…”, “explain” independent_exploration Productive 4 “I tried…”, “I noticed…”, “I figured out” debug_attempt Productive 3 “error”, “not working”, describing observed behavior neutral — 3 Navigation, “next module”, unmatched input answer_seeking Unproductive 1 “just do it”, “write it for me”, “give me the code” passive_acceptance Unproductive 1 Very short reply (<<15 chars) to a long response Layer 2: Context Injection. A SessionStart hook (learner-context.js) reads the learner profile at the beginning of each session. If the profile contains at least five non-neutral interactions, the hook computes the productive/unproductive ratio and injects a short teaching note into Claude’s context. The note is invisible to the student and includes the current engagement trend, dominant interaction pattern, and a concrete teaching directive. Three tiers govern the directive: a productive ratio ≥0.7≥ 0.7 encourages curiosity and deeper exploration; a ratio between 0.4 and 0.7 redirects answer-seeking behavior with guiding questions; a ratio below 0.4 provides additional structure and scaffolding. When a streak is active, the hook appends a priority alert: a struggle streak produces “Offer more scaffolding NOW” while an engagement streak produces “Student is in flow. Match with deeper content.” Only one streak type is surfaced per session to prevent conflicting signals. This gives Claude session-to-session memory of how the student learns without the student needing to say anything. Layer 3: Adaptation. At module boundaries (when the student requests the next module), instructions in CLAUDE.md direct the AI to read the accumulated engagement signals and decide whether to adjust the student’s Effective Level, a new field in CLAUDE.local.md that can diverge from the self-reported experience level: • If moduleAverageQuality ≥3.8≥ 3.8 and productive interactions (concept questions, independent exploration, and debug attempts) exceed 60% of non-neutral interactions: bump the Effective Level up one notch (e.g., beginner → intermediate for persona lookup). • If moduleAverageQuality ≤2.0≤ 2.0 and unproductive interactions (answer-seeking + passive acceptance) exceed 50%: bump down one notch. • Otherwise: hold steady. The Effective Level feeds into the existing persona progression table (Section 4), so a self-reported beginner who consistently asks deep conceptual questions may receive Collaborator-level teaching earlier than the default schedule. Conversely, a self-reported intermediate who is struggling receives additional Guide-level scaffolding. Changes are silent (the student is never told their level shifted), limited to one notch per module boundary, and module-level counters reset after each transition. Two-Timescale Adaptation. The streak booleans from Layer 1 and the Effective Level from Layer 3 create a two-timescale system. The slow clock (Effective Level) adjusts the persona schedule at module boundaries using aggregate statistics. The fast clock (streak detection) triggers scaffolding changes mid-module using sequential patterns. An asymmetric response principle governs the fast clock: the system is quicker to increase scaffolding (responding to struggle streaks immediately) than to withdraw it. This reflects a pedagogical heuristic grounded in the Hooshyar et al. finding: a student who is breezing through may simply be on an easy topic, but three consecutive answer-seeking messages is a strong signal of genuine difficulty. Over-scaffolding a strong student briefly costs little; under-scaffolding a struggling student risks permanent disengagement. 5.2 Design Constraints Three deliberate constraints shape the system. First, the observation layer uses keyword heuristics rather than LLM-based classification to avoid per-turn inference costs and latency; individual classifications are noisy, but aggregated over dozens of interactions per module the signal is clear. Second, Effective Level changes occur only at module boundaries to avoid disorienting the learner with intra-module persona shifts; streak-based scaffolding adjustments are the sole exception, and these modulate explanation depth rather than switching the active persona. Third, level changes are silent: informing the student of a demotion could be discouraging, and informing them of a promotion could create self-consciousness about maintaining it. 5.3 Relation to Prior Work The Chung et al. finding that engagement quality, not problem difficulty, mediates learning gains directly shaped the scoring function: categories reflecting active reasoning (concept questions, independent exploration) receive high scores, while categories reflecting passive consumption receive low scores. The Hooshyar et al. finding that non-mastery rules carry higher gradient sensitivity than mastery rules in neural-symbolic knowledge tracing models (Hooshyar et al., 2026) motivated both the streak detection mechanism and the asymmetric response principle: the system treats consecutive struggle signals as a stronger indicator than consecutive engagement signals, responding to the former immediately rather than waiting for aggregate statistics to shift. The architecture is deliberately lightweight compared to full Intelligent Tutoring Systems that maintain complex student models via knowledge tracing or POMDPs with particle filtering. The system trades model sophistication for deployability: it runs entirely through Claude Code’s hook system with no external dependencies, no API calls for observation, and no web backend. 6 Cross-Domain Transfer Design 6.1 The Unified Curriculum Constraint A core design decision: all five paths teach the same 10 Claude Code feature sets in the same order, designed to facilitate cross-domain transfer of tool mastery. The constraint means that a learner who completes the Canvas path and then begins Forge should encounter familiar feature progression in an unfamiliar domain context. The Claude Code skills are intended to transfer; only the project-specific application changes. This mirrors how professional developers use tools: the same Git workflow applies whether building a web app, a CLI tool, or a microservice. 6.2 Domain Adaptation While the feature sequence is fixed, each module is adapted to its project domain. Consider Module 7 (Guard Rails), which teaches PreToolUse hooks with decision control. The core Claude Code features are identical across all paths (permissionDecision, additionalContext, and updatedInput), but the exercises differ: • Canvas: A hook that blocks HTML writes missing alt attributes on images (accessibility enforcement). • Forge: A hook that validates storage JSON file structure before writes. • Nexus: A hook that checks API route configurations for required fields and security risks. • Sentinel: A hook that validates analysis rule definitions for correctness. • BYOP: A hook targeting a quality concern in the learner’s own codebase. Each exercise teaches the same three hook mechanisms (deny, inject context, and modify input) but contextualizes them within the project’s domain, aiming to reinforce both Claude Code mastery and domain-relevant best practices. 6.3 Feature Coverage Matrix The feature coverage matrix (Table 3) documents that all major Claude Code features currently covered are taught in all 5 paths. This matrix is enforced by the TestModuleConsistencyAcrossProjects test class, which extracts the **C features:** line from every module file and verifies symmetric coverage across all projects. A feature added to one path’s module that is not added to the other four will fail the test suite. Table 3: Feature coverage matrix (abridged). All currently covered C features are taught in all 5 paths. Full matrix available in the repository README. ✓ indicates the feature is covered in that path’s module. Feature Canvas Forge Nexus Sentinel BYOP Mod. CLAUDE.md, /init, /memory ✓ ✓ ✓ ✓ ✓ 1 Plan mode, git integration ✓ ✓ ✓ ✓ ✓ 2 .claude/rules/, @imports ✓ ✓ ✓ ✓ ✓ 3 Skills (SKILL.md, frontmatter) ✓ ✓ ✓ ✓ ✓ 4 Hooks (SessionStart, PostToolUse) ✓ ✓ ✓ ✓ ✓ 5 MCP servers, .mcp.json ✓ ✓ ✓ ✓ ✓ 6 PreToolUse, decision control ✓ ✓ ✓ ✓ ✓ 7 Subagents, chaining, parallel ✓ ✓ ✓ ✓ ✓ 8 Tasks, TDD, dependencies ✓ ✓ ✓ ✓ ✓ 9 Worktrees, plugins, eval ✓ ✓ ✓ ✓ ✓ 10 6.4 BYOP as Transfer Test The Bring Your Own Project (BYOP) path, added in v2.12.0, serves as the ultimate transfer test. Unlike the four tutorial paths where exercises are pre-designed, BYOP requires learners to identify appropriate applications of each Claude Code feature within their own codebase. For example, Module 7’s guard rail exercises require the learner to identify a quality concern in their project that warrants a PreToolUse hook; there is no pre-specified exercise. This demands genuine transfer of abstract tool knowledge to a concrete, unfamiliar context. 7 Step-Pacing and Information Load Management 7.1 The Information Overload Problem AI-as-instructor introduces a cognitive load challenge that has no direct parallel in human instruction. A human teacher naturally paces delivery through conversational turn-taking, reading body language, and responding to student confusion. An AI agent, when instructed to “teach Module 5,” can generate thousands of words of instruction in a single response, covering every step, explanation, and exercise without pause. This produces extraneous cognitive load (Sweller, 1988) that overwhelms working memory and inhibits learning. The problem is compounded by the terminal environment in which Claude Code operates. Unlike a graphical IDE with tabs and panels, a terminal session presents information as a linear text stream. A 3,000-word response scrolls past the visible area, requiring the learner to scroll back and forth to follow multi-step instructions while simultaneously executing commands. 7.2 STOP Blocks as Pacing Primitives We introduce STOP blocks, explicit pause directives embedded in module files that create hard boundaries in instruction delivery: ⬇ **STOP -- What you just did:** You created a guard that *prevents* Claude from writing inaccessible HTML. Unlike the PostToolUse validator from Module 5 that reports issues after the file is already written, this PreToolUse hook blocks the write entirely. A STOP block serves three functions: (1) it forces the AI to pause and wait for the learner’s response before continuing; (2) it provides a reflection prompt intended to consolidate learning from the preceding step; and (3) it creates a natural checkpoint where the learner can assess their understanding before moving forward. The pacing rule is enforced through a directive in CLAUDE.md that instructs the AI agent to halt after each STOP block. Because enforcement relies on the LLM’s adherence to prompt instructions rather than a hard system lock, occasional violations are possible, though in practice we have found compliance to be reliable: Deliver one step at a time. Each numbered step is a separate message. After completing a step, STOP and wait for the user to respond before continuing to the next step. If a step has a STOP block, that is a hard boundary. Do not continue past it under any circumstances. 7.3 Cross-Session State Tracking Step progress is tracked in CLAUDE.local.md, a per-session state file that persists across context compaction events and session restarts. After each step, the AI updates the current step marker: ⬇ Current Module: 7 Current Step: 7.3 This tracking mechanism addresses a unique challenge in LLM-based instruction: context window limits. When Claude Code’s context approaches capacity, it automatically compresses prior messages. Without external state tracking, the AI would lose its place in the curriculum. The CLAUDE.local.md file survives compaction because it is re-read at the start of each interaction, serving as a persistent breadcrumb. The system also includes a pre-advancement check: before proceeding to the next module, the AI must cross-reference the current step against the module’s Checkpoint section. If any steps were skipped (due to debugging tangents, user digressions, or context compaction), the AI returns to cover the missing steps before advancing. The learner does not need to track their own progress; the checkpoint structure does. 8 Automated Quality Assurance In the absence of runtime telemetry, automated testing provides our primary structural quality assurance. The test suite validates structural consistency across all 50 module files, using this as a proxy for pedagogical invariants. 8.1 Test Suite Overview Table 4 summarizes the 8 test files and their coverage domains. Table 4: Automated test suite summary. Tests are parametrized across 5 projects and 10 modules, yielding coverage across all 50 module files. Test counts reflect unique test functions before parametrization. Test File What It Validates Functions test_modules.py Module completeness, H1 titles, persona lines, C features, numbering, persona progression, adaptive persona table, cross-project feature consistency 15 test_file_structure.py Repository structure, required directories, required files, no unexpected files – test_context.py Context file existence, non-empty content, expected file list – test_hooks.py Hook configuration, script existence, expected hook events – test_skill.py Onboarding skill structure, frontmatter, step completeness – test_other_skills.py Non-onboarding skills (sync, release) structure and metadata – test_cross_refs.py Cross-references between modules, context files, and README – conftest.py Shared fixtures, project list, module file list, constants – 8.2 Parametrized Testing as Coverage Multiplier The key testing strategy is parametrization across the two-dimensional space of projects and modules. A single test function like test_persona_matches_module is parametrized over 5 projects × 10 modules = 50 test cases. This approach ensures that every structural invariant is verified for every module file in the repository, making it infeasible for a curriculum update to violate consistency without triggering a test failure. The parametrization is defined in conftest.py: ⬇ PROJECTS = ["canvas", "forge", "nexus", "sentinel", "byop"] MODULE_FILES = [ "01-setup.md", "02-blueprint.md", "03-rules-memory-context.md", "04-skills-commands.md", "05-hooks.md", "06-mcp-servers.md", "07-guard-rails.md", "08-subagents.md", "09-tasks-tdd.md", "10-parallel-plugins-eval.md", ] 8.3 Tests as Quality Proxy Beyond the pilot evaluation (Section 10), our test suite proxies for ongoing quality by enforcing invariants that are necessary (though not sufficient) conditions for a well-structured curriculum: • Completeness: Every project has all 10 modules; no extra files exist. • Structural consistency: Every module starts with a properly numbered heading, lists C features, and specifies a persona. • Pedagogical consistency: Persona assignments follow the prescribed progression across all projects. • Cross-project parity: The C features taught in each module are identical across all 5 projects. These tests do not evaluate whether the instruction is effective (that would require user data). They enforce structural properties that we consider prerequisites for effective instruction, particularly important given that the curriculum auto-updates when new tool versions are detected (Section 9). 9 Staying Current AI coding tools ship breaking changes on a cadence measured in days. A curriculum that teaches last week’s features is teaching the wrong things. Rather than treating content decay as a maintenance burden, c-self-train is designed to stay current automatically: when a learner begins the curriculum, the onboarding agent checks whether its teaching materials cover the learner’s installed version of Claude Code. If not, it updates the modules before instruction begins, so the learner always receives a current snapshot. The same pipeline can also be invoked standalone by a maintainer for bulk updates across all five project variants. 9.1 The Sync Pipeline The update logic is implemented as a Claude Code skill, /sync (Figure 5). Both invocation modes share the same six-step pipeline. When the tool has released new features since the curriculum was last updated, the pipeline: 1. Detects the version gap between the curriculum’s last-synced version and the latest Claude Code release. 2. Fetches the upstream changelog and triages entries (keeping Added/Changed/Removed, skipping bug fixes). 3. Maps relevant features to affected modules and context files using a predefined feature-to-module mapping. 4. Researches new features via web search, official documentation, or changelog text. 5. Updates affected module and context files, appending new steps before the Checkpoint section and matching the teaching persona depth for each target module. 6. Verifies all modified files for structural integrity (step numbering, checkpoint existence, STOP block preservation), reverting any file that fails. The two modes differ in trigger and scope: • Onboarding (automatic): When a learner runs /start, the onboarding agent executes the pipeline if it detects a version gap. Only the learner’s chosen project variant is updated, so the sync completes quickly and instruction can begin with current materials. • Standalone (manual): A maintainer invokes /sync directly to update all five project variants in bulk, then reviews and commits the results. 1. Detectversion gap2. Fetch &triage changelog3. Map tomodules4. Researchfeatures5. Updatefiles6. VerifyintegrityPass?DoneRevertfileyesno Figure 5: The sync pipeline (/sync skill). The pipeline detects upstream Claude Code releases, triages changelog entries, appends new steps to affected modules, and verifies structural integrity. Files that fail verification are reverted. During onboarding, only the learner’s chosen project is updated; standalone invocation updates all five variants. The safe-append rule: for module files, the pipeline never modifies or renumbers existing steps. New content is inserted immediately before the Checkpoint section at the end of each module. This ensures that learners who are mid-curriculum will not encounter renumbered or altered steps after a sync, and that the step-tracking system (Section 7) remains valid across updates. Context files (reference documentation in context/) are updated in-place, since learners do not step through them. 9.2 Implications The auto-updating design has two implications: 1. Curriculum currency: The AI coding tool landscape evolves on timescales of days or weeks rather than months or years, making static curricula obsolete quickly. Because the onboarding agent checks for upstream changes at the start of each learner’s journey, new features are incorporated into the curriculum at the point of use. The learner always receives teaching materials that match their installed tool version. 2. Scalability: The sync pipeline scales to any number of project variants without proportional human effort. Adding BYOP as a 5th path required generating 10 module files, which the pipeline then maintains alongside the original 40. 10 Pilot Evaluation To assess whether the curriculum produces measurable self-efficacy gains, we conducted a within-subjects pilot study with pre- and post-training self-assessments. 10.1 Methodology Participants. We recruited 27 professional software engineers from a single client organization. Participation was voluntary, and participants knew the author designed the curriculum. Participants self-reported their prior experience with Claude Code at one of three levels: beginner (n=9n=9), intermediate (n=8n=8), or advanced (n=10n=10). All participants completed the full curriculum through the onboarding agent and at least one project path. Instrument. We designed a 10-item self-efficacy questionnaire mapped to the curriculum’s feature progression (full item text in Appendix A). Each item used a 5-point Likert scale (1 = Strongly Disagree, 5 = Strongly Agree). The items assessed two categories of skill: • Foundational skills (taught in early modules): explaining Claude Code’s purpose, completing end-to-end changes without step-by-step guidance, understanding and using project memory (CLAUDE.md), and knowing when to plan versus execute immediately. • Advanced skills (taught in later modules): understanding and creating custom skills (slash commands), understanding and setting up hooks for automated workflows, and troubleshooting off-track agent behavior by adjusting context, instructions, or memory. Procedure. Participants completed the pre-survey before beginning any curriculum module and the post-survey after completing their final module. The same 10 items appeared in both surveys. Surveys were self-administered via Google Forms with anonymized user IDs to enable paired analysis. Analysis. We used paired t-tests (two-tailed) for each item and overall, with Cohen’s d as the effect size measure. We also performed a Wilcoxon signed-rank test as a non-parametric confirmation of the overall result. 10.2 Results Table 5 presents per-item results. All 10 items showed statistically significant gains (p<0.001p<0.001), with large effect sizes across the board (Cohen’s d range: 0.89–2.79). Table 5: Pre/post self-efficacy ratings (n=27n=27). All gains are statistically significant at p<0.001p<0.001 (paired t-test, two-tailed). Scale: 1 = Strongly Disagree, 5 = Strongly Agree. Skill Area Pre Post Gain t(26) d Foundational skills Explain what C is and when useful 3.63 4.37 +0.74 7.32 1.41 End-to-end change without help 3.44 4.33 +0.89 5.77 1.11 Understand project memory 3.07 3.59 +0.52 4.65 0.89 Use memory across sessions 2.81 3.81 +1.00 7.65 1.47 Plan vs. execute immediately 3.52 4.04 +0.52 5.29 1.02 Advanced skills Understand skills (slash commands) 3.15 3.81 +0.67 6.24 1.20 Create and use a skill 2.63 3.63 +1.00 13.25 2.55 Understand hooks 2.41 3.78 +1.37 11.32 2.18 Set up a hook 1.96 3.04 +1.07 14.50 2.79 Troubleshoot off-track behavior 3.04 3.67 +0.63 5.79 1.11 Overall 2.97 3.81 +0.84 22.20 1.35 The overall gain was confirmed by a Wilcoxon signed-rank test (W=0.0W=0.0, p<0.00001p<0.00001), indicating that 26 of 27 participants improved (one advanced user scored at ceiling on both administrations). Gains by expertise level. Table 6 breaks down gains by self-reported experience. Beginners showed the largest gains (+1.18), intermediates were close behind (+0.94), and advanced users showed smaller but still significant gains (+0.46). This pattern is consistent with ceiling effects: advanced users started closer to the scale maximum, leaving less room for measured improvement. All three subgroups reached p<0.001p<0.001. Table 6: Mean self-efficacy gains by expertise level. All subgroups show significant improvement (p<0.001p<0.001). Level n Pre Post Gain t Beginner 9 1.61 2.79 +1.18 22.60 Intermediate 8 2.91 3.85 +0.94 14.36 Advanced 10 4.23 4.69 +0.46 6.15 10.3 Interpretation Two patterns stand out. First, the largest effect sizes appear on advanced features: setting up hooks (d=2.79d=2.79), creating skills (d=2.55d=2.55), and understanding hooks (d=2.18d=2.18). These are the features taught in later modules where the persona has shifted from Guide to Collaborator or Peer, suggesting that the progressive scaffolding may be especially valuable for compositional features that are difficult to learn from documentation alone. Second, the expertise-level gradient supports the curriculum’s experience-stratified persona boundaries. Beginners, who receive more Guide-phase modules (4 of 10), showed the largest absolute gains. Advanced users, who start in Collaborator mode (1/3/5/1 distribution), still improved on advanced features like hooks and skills, even though their foundational scores were already near ceiling. This suggests the curriculum provides value across experience levels, though through different mechanisms: foundational scaffolding for beginners, advanced feature depth for experienced users. Limitations of this evaluation. This pilot has several constraints that temper interpretation. The study uses self-reported efficacy, not task-based performance; participants may overestimate or underestimate their abilities. There is no control group, so gains could partially reflect practice effects or exposure rather than the specific pedagogical design. The sample is drawn from a single client organization, limiting generalizability. Because participants knew the author designed the curriculum, demand effects on self-report measures are possible, though self-administered anonymous surveys mitigate this risk. Finally, while the 5-point scale is standard, a 7-point Likert scale would provide finer discrimination in future studies. 11 Discussion 11.1 Framing as a System Paper This work follows the system paper tradition in AI research, where several influential projects have described architectural contributions without user studies. LangChain (Chase, 2022) documents a composability framework; MetaGPT (Hong et al., 2023) presents a multi-agent collaboration framework. Both describe design decisions, architectural patterns, and capabilities without empirical user evaluation. Our contributions are similarly system-level design decisions: persona progression, unified curricula, step-pacing, and auto-updating design. The pilot evaluation (Section 10) provides initial empirical support, with significant reported self-efficacy gains across all 10 assessed skill areas (n=27n=27, all p<0.001p<0.001). The system is open-source, enabling independent replication and evaluation, and the test suite provides verifiable structural guarantees. 11.2 Structured Scaffolding, Not Structured Learning A clarification on terminology: c-self-train is not structured learning in the traditional sense of linear courseware with predetermined interactions. The module sequence and feature progression are fixed, but the learning experience within each module is open-ended. The learner converses with an agentic AI that adapts to their questions, debugs their real errors, and responds to the specific state of their project. Two learners completing the same module will have substantively different interactions. The BYOP (Bring Your Own Project) path makes this especially clear: there are no pre-scripted exercises at all; the learner must identify where each Claude Code feature applies within their own codebase. The curriculum is better understood as sequenced scaffolding around an exploratory agent interaction, more akin to a choose-your-own-adventure with guided checkpoints than to a traditional self-paced course. 11.3 Comparison with Existing Resources Table 7 compares c-self-train with existing AI coding assistant learning resources across six dimensions. Table 7: Comparison with existing AI coding assistant learning resources. “Docs” refers to vendor reference documentation (e.g., API docs, CLI reference), not vendor-hosted courses, which fall under Bootcamps. Dimension Docs YouTube Bootcamps c-self-train Progressive structure Minimal Rare Partial Full (10 modules) Hands-on projects No Demo only Exercises Full projects Instructional tone Static Presenter style Instructor style 4-stage progression Feature coverage Complete Selective Selective Complete Cross-domain transfer N/A Single domain Single domain 5 domains Adaptive scaffolding No No Rare Runtime-adaptive Self-updating Manual Never Rarely Auto-updating 11.4 Limitations Preliminary empirical evaluation. The pilot study (Section 10) provides initial evidence of self-efficacy gains but uses self-report measures rather than task-based performance assessment, lacks a control group, and draws from a single organization. Whether the persona progression produces measurable learning gains compared to a static persona, or whether STOP blocks reduce cognitive load versus unconstrained delivery, remain open questions that require controlled experiments. Heuristic engagement classification. The adaptive learning system (Section 5) classifies learner engagement using keyword pattern matching rather than LLM-based semantic analysis. This approach avoids per-turn inference costs but may misclassify messages: a student pasting an error message for context (not debugging) would be classified as debug_attempt, and rhetorical questions could be scored as concept questions. The streak detection window (three consecutive same-type interactions out of a five-element buffer) and the promotion/demotion thresholds (3.8 and 2.0, respectively) were set based on authorial judgment rather than empirical calibration. A misclassified interaction within the streak window could trigger or suppress an intervention. Whether the adaptive system, including the two-timescale design, produces measurable learning gains compared to the static persona schedules remains an open empirical question. Sync pipeline accuracy. The sync pipeline (Section 9) verifies structural integrity (step numbering, checkpoint preservation, STOP block presence) through the test suite, but does not verify the semantic correctness of LLM-generated updates. Whether generated teaching content accurately reflects upstream feature changes, and how often the pipeline succeeds or silently produces incorrect content, has not been empirically measured. In practice, a human maintainer reviews standalone bulk updates before commit, which mitigates the risk for the primary update mode. Onboarding-mode updates are more automated and would benefit from explicit accuracy measurement across multiple release cycles. Single tool implementation. The current implementation targets Claude Code. Adapting the framework to other agentic tools (Copilot’s agent mode, Cursor’s agentic features, or future tools) would require new module content and feature mappings, though the pedagogical architecture, including persona progression, unified curricula, step-pacing, and the auto-updating design pattern, is designed to transfer. More broadly, while the pedagogical patterns (persona progression, step-pacing, auto-updating) are domain-agnostic, all validation in this paper targets software development; applying them to non-development domains such as legal AI tools or scientific research agents remains a direction for future work. English only. All 50 module files, 22 context documents, and the onboarding flow are written in English. Localization would require not just translation but cultural adaptation of the persona progression model. No telemetry. The adaptive learning system writes engagement signals to a local file (learner-profile.json), but this data never leaves the learner’s machine. The system collects no centralized usage data. We cannot report aggregate completion rates, common failure points, or time-on-task metrics. The local-only, privacy-respecting design is intentional but limits ongoing empirical evaluation beyond the pilot study reported in Section 10. 11.5 Future Work The current system validates the pedagogical architecture but leaves several empirical and engineering questions open. The following extensions would address the most significant gaps: • Semantic engagement classification: Replace the keyword-based heuristic classifier in the observation hook with an LLM-based or embedding-based classifier that can distinguish genuine concept questions from rhetorical ones and detect engagement patterns invisible to keyword matching. Calibrate the quality scores and adaptation thresholds empirically against learning outcome data. • Multi-tool implementations: Implement the curriculum framework for other agentic coding tools (Copilot’s agent mode, Cursor’s agentic features), validating that the pedagogical architecture transfers as designed. • User telemetry: With appropriate consent, collect anonymized usage data to measure completion rates, identify drop-off points, and validate the persona progression’s impact on learning outcomes. • LLM pedagogical evaluation: Use a separate LLM to evaluate the quality of generated instruction, creating an automated proxy for human expert review. • Community extensions: Enable community-contributed project paths, expanding the cross-domain coverage beyond the current five options. 11.6 Broader Impact Auto-updating curricula introduce a tradeoff between currency and stability: if the sync pipeline propagates an error, all new learners receive incorrect instruction until the maintainer intervenes. The safe-append design (Section 9) and the test suite (Section 8) mitigate this risk, but do not eliminate it. Additionally, the curriculum is English-only and assumes access to Claude Code, which requires a paid subscription, potentially limiting access for learners in resource-constrained settings. We believe the open-source release partially addresses this concern by enabling community adaptation and localization. 12 Conclusion We have presented c-self-train, a modular interactive curriculum framework for learning AI coding assistants through hands-on project construction. Taken together, the five contributions: persona progression, adaptive learning, unified cross-domain sequencing, step-pacing, and auto-updating design, demonstrate that structured, progressive pedagogy for agentic AI tools is both feasible and amenable to automated maintenance. A parametrized test suite enforces structural consistency as a proxy for pedagogical invariants across all 50 module files, providing a quality assurance layer that keeps the curriculum coherent as it evolves. A pilot evaluation with 27 participants provides initial empirical support: all 10 assessed skill areas showed statistically significant reported self-efficacy gains (p<0.001p<0.001), with the largest effects on advanced features like hooks and skills (d up to 2.79). Beginners gained the most overall (+1.18 on a 5-point scale), while advanced users still improved on compositional features, suggesting the experience-stratified persona boundaries provide value across skill levels. Beyond the specific curriculum, five design patterns in c-self-train are separable from the implementation and applicable to other AI-mediated instructional systems: • The staged-persona adaptation of Gradual Release of Responsibility, reinterpreting the classroom handoff phases (“I do it” through “You do it alone”) for single-learner AI instruction. • The two-timescale engagement adaptation architecture, combining slow module-boundary adjustments with fast streak-based interventions, governed by an asymmetric response principle that scaffolds struggling learners more readily than it withdraws support. • The safe-append rule for updating instructional content without invalidating mid-flow learners, enabling curricula to evolve without breaking in-progress instruction. • The parametrized structural test suite as a proxy for pedagogical invariants, making it infeasible for content updates (whether human or LLM-generated) to silently violate pedagogical properties. • The unified cross-domain curriculum in which multiple project paths share identical feature sequencing, producing transfer-friendly learning without duplicating pedagogical design effort. More broadly, as agentic AI tools proliferate across domains beyond software development, from legal research to scientific analysis to creative production, pedagogical systems that adapt their scaffolding and update their content automatically will become a necessary complement to tool documentation. The patterns above offer a starting point for that broader design space. Availability. The c-self-train curriculum, test suite, and onboarding agent are open-source and available at https://github.com/zainnab-sparq/c-self-train under the MIT License. This paper describes the system at tag v2.25.0 (commit 5f4c7d1); subsequent versions may differ in implementation details. The repository includes all module files, context documents, test fixtures, and instructions for running the curriculum or invoking the sync pipeline independently. Anonymized pre/post response data from the pilot evaluation (Section 10) is available from the corresponding author on request. Acknowledgments The design of c-self-train was inspired in part by two open-source projects. Everything Claude Code (Affaan, 2025) demonstrated that Claude Code’s extensibility surface (agents, skills, hooks, and commands) could be systematically organized into a cohesive configuration system, motivating our effort to build a structured learning pathway through those same features. OpenClaw (OpenClaw Contributors, 2025) showed how an open-source agent platform with extensible skills could serve a broad developer community, reinforcing our commitment to open, community-accessible educational tooling. We are grateful to the maintainers of both projects for their contributions to the ecosystem. References Affaan [2025] Muhammad Affaan. Everything claude code: A production-ready configuration system for Claude Code. https://github.com/affaan-m/everything-claude-code, 2025. Anderson and Krathwohl [2001] Lorin W. Anderson and David R. Krathwohl. A Taxonomy for Learning, Teaching, and Assessing: A Revision of Bloom’s Taxonomy of Educational Objectives. Longman, 2001. Anthropic [2025a] Anthropic. Claude code: An agentic coding tool. https://docs.anthropic.com/en/docs/claude-code, 2025a. Anthropic [2025b] Anthropic. Anthropic courses. https://w.anthropic.com/ai-fluency, 2025b. Becker et al. [2023] Brett A. Becker, Paul Denny, James Finnie-Ansley, Andrew Luxton-Reilly, James Prather, and Eddie Antonio Santos. Programming is hard – or at least it used to be: Educational opportunities and challenges of AI code generation. In Proceedings of the 54th ACM Technical Symposium on Computer Science Education, pages 500–506, 2023. doi: 10.1145/3545945.3569759. Bloom et al. [1956] Benjamin S. Bloom, Max D. Engelhart, Edward J. Furst, Walker H. Hill, and David R. Krathwohl. Taxonomy of Educational Objectives: The Classification of Educational Goals. David McKay Company, 1956. Chase [2022] Harrison Chase. LangChain: Building applications with LLMs through composability. https://github.com/langchain-ai/langchain, 2022. Chen et al. [2021] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021. Chung et al. [2025] Bobby Chung, Chenyue Zhang, Alvin Kung, Hamsa Bastani, and Osbert Bastani. Effective personalized AI tutors via LLM-guided reinforcement learning. Working Paper, University of Pennsylvania, 2025. RCT with 770 high school students; adaptive problem sequencing improved exam performance by 0.15 SD (p<0.05p<0.05), with gains mediated by engagement quality. Cursor, Inc. [2024] Cursor, Inc. Cursor: The AI-first code editor. https://cursor.com, 2024. Fisher and Frey [2013] Douglas Fisher and Nancy Frey. Better Learning Through Structured Teaching: A Framework for the Gradual Release of Responsibility. ASCD, 2nd edition, 2013. GitHub [2022] GitHub. Github Copilot: Your AI pair programmer. https://github.com/features/copilot, 2022. Hong et al. [2023] Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, et al. MetaGPT: Meta programming for a multi-agent collaborative framework. arXiv preprint arXiv:2308.00352, 2023. Hooshyar et al. [2026] Danial Hooshyar, Gustav Šír, Yeongwook Yang, Tommi Kärkkäinen, Raija Hämäläinen, Ekaterina Krivich, Mutlu Cukurova, Dragan Gašević, and Roger Azevedo. Neural-symbolic knowledge tracing: Injecting educational knowledge into deep learning for responsible learner modelling. arXiv preprint arXiv:2604.08263, 2026. Neural-symbolic model achieving 0.90 AUC; non-mastery rules carry higher gradient sensitivity than mastery rules, indicating sequential failure patterns are more informative for learner modeling. Kazemitabaar et al. [2023] Majeed Kazemitabaar, Justin Chow, Carl Ka To Ma, Barbara J. Ericson, David Weintrop, and Tovi Grossman. Studying the effect of AI code generators on supporting novice learners in introductory programming. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems, pages 1–23, 2023. doi: 10.1145/3544548.3580919. Kazemitabaar et al. [2024] Majeed Kazemitabaar, Runlong Ye, Xiaoning Wang, Austin Z. Henley, Paul Denny, Michelle Craig, and Tovi Grossman. CodeAid: Evaluating a classroom deployment of an LLM-based programming assistant that balances student and educator needs. In Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems, 2024. doi: 10.1145/3613904.3642773. Kosmyna et al. [2025] Nataliya Kosmyna, Eugene Hauptmann, Ye Tong Yuan, Jessica Situ, Xian-Hao Liao, Ashly Vivian Beresnitzky, Iris Braunstein, and Pattie Maes. Your brain on ChatGPT: Accumulation of cognitive debt when using an AI assistant for essay writing task. arXiv preprint arXiv:2506.08872, 2025. Li and Zheng [2026] Shan Li and Juan Zheng. A scoping review of large language model-based pedagogical agents. arXiv preprint arXiv:2604.12253, 2026. PRISMA-ScR review of 52 studies (Nov 2022–Jan 2025); proposes four-dimension taxonomy: interaction approach, domain scope, role complexity, system integration. Madaan et al. [2023] Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, et al. Self-refine: Iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36, 2023. OpenAI [2025] OpenAI. Codex: An autonomous coding agent. https://openai.com/index/introducing-codex/, 2025. OpenClaw Contributors [2025] OpenClaw Contributors. OpenClaw: Open-source personal AI assistant platform. https://github.com/openclaw/openclaw, 2025. Papert [1980] Seymour Papert. Mindstorms: Children, Computers, and Powerful Ideas. Basic Books, 1980. Prather et al. [2024] James Prather, Brent N. Reeves, Juho Leinonen, Stephen MacNeil, Arisoa Randrianasolo, Brett A. Becker, Bailey Kimmel, Jared Wright, and Ben Briggs. The widening gap: The benefits and harms of generative AI for novice programmers. In Proceedings of the 2024 ACM Conference on International Computing Education Research, 2024. doi: 10.1145/3632620.3671116. Shinn et al. [2023] Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36, 2023. Sweller [1988] John Sweller. Cognitive load during problem solving: Effects on learning. Cognitive Science, 12(2):257–285, 1988. Vincent [2025] Jesse Vincent. Superpowers: Agentic skills framework for software development. https://github.com/obra/superpowers, 2025. Wang et al. [2024] Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, et al. A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6), 2024. White et al. [2023] Jules White, Quchen Fu, Sam Hays, Michael Sandborn, Carlos Olea, Henry Gilbert, Ashraf Elnashar, Jesse Spencer-Smith, and Douglas C. Schmidt. A prompt pattern catalog to enhance prompt engineering with ChatGPT. arXiv preprint arXiv:2302.11382, 2023. Yan [2025] Lixiang Yan. From passive tool to socio-cognitive teammate: A conceptual framework for agentic AI in human-AI collaborative learning. arXiv preprint arXiv:2508.14825, 2025. Appendix A Survey Instrument The following 10 items were administered identically as pre- and post-training self-assessments. Each item used a 5-point Likert scale: 1 = Strongly Disagree, 2 = Disagree, 3 = Neither Agree nor Disagree, 4 = Agree, 5 = Strongly Agree. A screening question (“Have you taken the Claude Code training?”) routed participants to the pre- or post-survey. 1. I can explain what Claude Code is and when it is useful. 2. I can get Claude Code working in a new repository and complete a small change end-to-end (make edits, verify, and finish) without step-by-step help. 3. I understand what project memory (CLAUDE.md) is in Claude Code. 4. I can use project memory (CLAUDE.md) to make Claude behave consistently across sessions in the same repo. 5. I know when to plan a task first (before making edits) versus when to execute immediately. 6. I understand what a skill (custom slash command) is in Claude Code. 7. I can create and use a skill (custom slash command) to standardize a repeated workflow. 8. I understand what a hook is in Claude Code. 9. I can set up a hook so an automated action runs at the right time during a Claude Code workflow (for example formatting, linting, or tests). 10. When Claude is off-track, I can troubleshoot effectively by changing context, instructions, or memory to fix the root cause.

Instant research discovery