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

> Discover how AI tutor skills learn, start-learning, and course-guide coordinate in ai-engineering-from-scratch. Explore their hierarchical pipeline for learner management and routing.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: internals
- Published: 2026-08-29

---

**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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/skills/start-learning/SKILL.md) (lines 31-34).

According to the source code, `start-learning` creates [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md) → `learn` (generic curriculum)
- [`MCP-LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/MCP-LEARNING.md) → `learn-mcp` (Model-Context-Protocol track)
- [`AGENT-SKILLS-LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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.

```python
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:

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

```

## Summary

- **`start-learning`** creates the [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/skills/learn/SKILL.md) maps specific state files to their respective skills (lines 54-61). When resuming, the system checks for [`LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md), [`MCP-LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/MCP-LEARNING.md), or [`AGENT-SKILLS-LEARNING.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/LEARNING.md) plan. This separates the tutoring logic from the curriculum content, allowing non-technical authors to update materials without modifying the skill code.