How the AI Tutor Skills `learn`, `start-learning`, and `course-guide` Interact and Coordinate

The start-learning, learn, and course-guide skills in rohitg00/ai-engineering-from-scratch form a hierarchical decision pipeline that manages learner onboarding, daily tutoring sessions, and intent-based routing through shared state files and defined host contracts.

The rohitg00/ai-engineering-from-scratch repository implements a modular AI tutoring system where three distinct skills coordinate to deliver personalized curriculum delivery. Understanding how these AI tutor skills interact reveals a state-driven architecture that persists learner progress across sessions while dynamically routing queries to appropriate specialized modules. Each skill maintains its own SKILL.md contract while sharing a common resume routing table to ensure seamless hand-offs between onboarding, active learning, and navigation tasks.

The Three Core Skills and Their Responsibilities

Each skill operates as a portable module with a specific role in the learner lifecycle:

• start-learning: Handles initial onboarding, runs placement quizzes, and generates the persistent LEARNING.md state file that serves as the single source of truth for the learner's roadmap.
• learn: Manages day-to-day tutoring by reading the existing plan, fetching the next lesson from phases/…/docs/en.md, presenting material section-by-section, administering quizzes, and appending progress updates.
• course-guide: Functions as an intent router that interprets diverse learner queries—from topic lookups to struggle diagnosis—and forwards requests to the appropriate skill or specialized route.

Coordination Flow and State Transitions

The interaction between these skills follows a deterministic pipeline based on the existence and content of state files.

Initial Onboarding with start-learning

When a learner initiates the curriculum with phrases like "I want to start learning AI engineering," the host resolves this to the start-learning skill according to the host contract defined in skills/start-learning/SKILL.md (lines 31-34).

According to the source code, start-learning creates LEARNING.md to record the learner's mission, entry point, and initial path (lines 15-20). This file becomes the persistent anchor for all subsequent tutoring sessions.

Resuming or Pivoting

If LEARNING.md already exists when start-learning is invoked, the skill offers two explicit options: resume via the learn skill, or redo the placement quiz (lines 93-100). This check prevents duplicate onboarding and ensures returning learners bypass unnecessary setup steps.

Daily Lesson Delivery with learn

When the learner requests the next lesson or specific instruction, the host dispatches to the learn skill as specified in its host contract (lines 25-28).

The learn skill performs several coordinated actions:

1. Reads the existing LEARNING.md plan to identify the current position.
2. Fetches the corresponding lesson content from the repository's phases/ directory.
3. Presents material section-by-section with interactive quizzes.
4. Appends completion status and next steps back to LEARNING.md.

Navigation Routing with course-guide

For non-sequential requests such as "where do I learn attention?" or "I'm stuck on loss-NaN", the host routes to course-guide. This skill parses the request type—whether topic lookup, struggle diagnosis, meta-question, or certification prep (lines 74-92).

Depending on the parsed intent, course-guide either:

• Looks up the appropriate lesson in the repository's README.md contents table and returns the next command (typically learn) (lines 36-41).
• Hands off to specialized routes like learn-mcp for Model-Context-Protocol queries, learn-agent-skills for agent development, or claude-certification for certification pathways.

Resume Routing and Cross-Skill State Management

Both start-learning and learn share a resume routing table that maps state files to their owning skills (lines 54-61). This table identifies:

• LEARNING.md → learn (generic curriculum)
• MCP-LEARNING.md → learn-mcp (Model-Context-Protocol track)
• AGENT-SKILLS-LEARNING.md → learn-agent-skills (Agent development track)

When a generic "resume" request arrives, the system checks these files to determine the appropriate skill and immediately delegates control, bypassing generic onboarding and preserving the learner's exact position in the curriculum hierarchy.

Practical Implementation Examples

You can invoke this coordinated pipeline programmatically or through host-specific slash commands.

from pathlib import Path
import subprocess

def invoke(skill, *args):
    """Run a skill via its host-specific command."""
    cmd = ["bash", "-c", f"{skill} {' '.join(args)}"]
    return subprocess.run(cmd, capture_output=True, text=True).stdout

# 1. Initialize a new learner plan

print(invoke("start-learning"))   

# Creates LEARNING.md with placement results

# 2. Continue the curriculum

print(invoke("learn"))            

# Reads LEARNING.md, fetches next lesson, updates progress

# 3. Query the router for specific topics

print(invoke("course-guide", "teach me attention"))  

# Returns routing decision and next command

In Claude Code environments, these become slash commands:

/start-learning
/learn
/course-guide teach me attention

Summary

• start-learning creates the LEARNING.md state file and handles initial placement, offering resume options if the learner already exists.
• learn drives daily tutoring by reading the plan, delivering lessons from phases/…/docs/en.md, and updating progress back to the state file.
• course-guide acts as an intent router, parsing learner queries and forwarding them to learn, start-learning, or specialized tracks like learn-mcp and learn-agent-skills.
• Resume routing allows seamless hand-offs between skills by checking state file ownership before invoking the appropriate handler.
• State persistence through LEARNING.md and specialized variants ensures continuity across disjointed tutoring sessions.

Frequently Asked Questions

What happens if I invoke start-learning when I already have a LEARNING.md file?

The start-learning skill detects the existing state file and presents two options: resume the existing plan via the learn skill, or delete the current progress and retake the placement quiz (lines 93-100). This prevents accidental overwrites while allowing curriculum resets.

How does course-guide decide which skill to route a request to?

The skill analyzes the request type against six categories defined in skills/course-guide/SKILL.md: topic lookup, struggle diagnosis, meta-questions, certification, MCP, and Agent Skills (lines 74-92). Topic lookups scan the README.md contents table, while specific tracks trigger hand-offs to specialized skills like learn-mcp or claude-certification.

Can I switch between the generic curriculum and specialized tracks like MCP without losing progress?

Yes. The resume routing table maintained in skills/learn/SKILL.md maps specific state files to their respective skills (lines 54-61). When resuming, the system checks for LEARNING.md, MCP-LEARNING.md, or AGENT-SKILLS-LEARNING.md and invokes the corresponding skill, preserving the exact position within each track.

What file contains the actual lesson content that learn presents?

The learn skill fetches lesson content from the repository's phases/ directory structure, specifically targeting phases/…/docs/en.md files according to the path specified in the learner's LEARNING.md plan. This separates the tutoring logic from the curriculum content, allowing non-technical authors to update materials without modifying the skill code.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}