# How Claude and Cursor Agent Skills Like `/find-your-level` and `/check-understanding` Work

> Explore how Claude and Cursor agent skills like find-your-level and check-understanding parse slash commands load markdown skill definitions execute quiz logic and map scores to personalized paths.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: deep-dive
- Published: 2026-06-21

---

**The Claude and Cursor agents in the AI Engineering from Scratch curriculum parse slash-commands by loading markdown-based skill definitions from local directories, executing interactive quiz logic via the `AskUserQuestion` tool, and mapping scores to personalized curriculum paths.**

The open-source repository `rohitg00/ai-engineering-from-scratch` implements a lightweight, portable skill system that allows AI agents to conduct placement assessments and knowledge checks without external APIs. These skills are self-contained markdown files with structured front-matter that define trigger phrases, procedural steps, and scoring logic.

## The Markdown Skill Architecture

Each skill is a **markdown file with YAML front-matter** stored in the `.claude/skills/` and `.cursor/skills/` directories. The front-matter block (delimited by `---`) declares the skill's metadata, including its name, version, description, and trigger phrases, while the body contains the procedural logic and content.

When the agent runtime starts, it scans the skill directories and builds a manifest that maps slash-commands like `/find-your-level` to their corresponding file paths. This registration happens through the [`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py) script, which copies the skill folders to the user's home directory locations (`~/.claude/skills/` and `~/.cursor/skills/`) and updates the agent's internal command registry.

## How `/find-your-level` Works

The **Find-Your-Level** skill, defined in [`.claude/skills/find-your-level/SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/.claude/skills/find-your-level/SKILL.md), acts as a placement quiz that determines which phase of the curriculum a learner should start with.

### Quiz Structure and Scoring

The skill presents **10 multiple-choice questions** covering five knowledge areas—Math & Statistics, Programming, Machine Learning, Deep Learning, and MLOps—with two questions per domain. Each correct answer awards **1 point**, producing a raw score between 0 and 10.

The skill file contains a hardcoded **Score-to-Entry-Point** table (lines 73-80) that converts the total score into a recommended starting phase:

- **Score 0-3**: Start at Phase 0 (Setup & Tooling)
- **Score 4-6**: Start at Phase 1 (Math Foundations)
- **Score 7-8**: Start at Phase 2 (ML Fundamentals)
- **Score 9-10**: Start at Phase 3 (Deep Learning)

### Personalized Path Generation

After calculating the score, the agent generates a markdown table (lines 102-138 in [`SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/SKILL.md)) that marks every curriculum phase as **Skip**, **Review**, or **Do**. The table pulls estimated hour values from [`ROADMAP.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ROADMAP.md) and sums them to provide a total time commitment. The agent outputs this table along with a brief narrative recommendation.

```python

# Conceptual flow when /find-your-level is triggered

def execute_find_your_level():
    skill = load_skill("~/.claude/skills/find-your-level/SKILL.md")
    score = 0
    for question in skill.questions:
        answer = AskUserQuestion(question.text, options=question.options)
        if answer == question.correct:
            score += 1
    entry_phase = map_score_to_phase(score)  # Lookup table logic

    return generate_learning_path(entry_phase)

```

## How `/check-understanding` Works

The **Check-Understanding** skill, located at [`.claude/skills/check-understanding/SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/.claude/skills/check-understanding/SKILL.md), validates mastery of a specific curriculum phase rather than assessing broad placement.

### Phase-Specific Question Generation

Unlike the static question bank in `/find-your-level`, this skill dynamically generates **8 multiple-choice questions** (4 conceptual, 4 practical) drawn directly from the lesson documents of the requested phase. The skill accepts either a numeric phase identifier (e.g., "2") or a textual name (e.g., "ML Fundamentals") and loads the corresponding content from the repository's phase directories.

### Interactive Assessment Loop

The agent uses the **`AskUserQuestion`** tool to present each question sequentially, tracks the user's selections in memory, and computes the final accuracy percentage. Based on the score, the skill recommends specific next steps: proceeding to the next phase, reviewing particular subtopics, or repeating hands-on exercises.

```bash

# Example invocation after installation

$ claude-code /check-understanding "Phase 1"
>>> Loading Phase 1: Math Foundations...
>>> Question 1/8 (Conceptual): What is the determinant of a 2x2 matrix [[a, b], [c, d]]?
>>> A) ad - bc  B) ad + bc  C) ac - bd  D) ab + cd
>>> ...
>>> Score: 6/8 (75%). Recommendation: Review gradient descent before proceeding.

```

## Skill Registration and Installation

The [`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py) file handles the deployment of these capabilities to the agent runtime. The script performs three critical operations:

1. **Copies skill directories** from the repository's `.claude/skills/` and `.cursor/skills/` paths to the user's home configuration folders (`~/.claude/skills/` and `~/.cursor/skills/`).
2. **Updates the manifest** that maps trigger strings (e.g., "/find-your-level", "where should I start?") to the absolute paths of the skill markdown files.
3. **Validates the schema** to ensure the front-matter contains required fields like `name`, `version`, and `triggers`.

This installation step is required because the agent runtime only reads skills from the user's home directory, not from arbitrary repository locations.

## Cross-Platform Compatibility

Both Claude Code and Cursor share the **identical markdown-based skill schema**, making the behaviors interchangeable. The only difference is the filesystem location:

- **Claude Code**: Reads from `~/.claude/skills/`
- **Cursor**: Reads from `~/.cursor/skills/`

When the user types `/find-your-level` in either environment, the agent executes the same quiz logic, references the same scoring tables, and produces the same output format because both agents parse the same [`SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/SKILL.md) structure.

## Summary

- **Skill definitions** are markdown files with YAML front-matter stored in `.claude/skills/` and `.cursor/skills/`.
- **`/find-your-level`** runs a static 10-question placement quiz and maps scores to curriculum phases using a lookup table in [`SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/SKILL.md).
- **`/check-understanding`** generates 8 dynamic questions from phase-specific lesson content to validate mastery.
- **[`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)** deploys skills to `~/.claude/skills/` and `~/.cursor/skills/` and registers slash-command triggers.
- Both agents use the **`AskUserQuestion`** tool to handle interactive input and maintain state during quiz execution.
- The system is fully local and requires no external services beyond the agent runtime.

## Frequently Asked Questions

### What file format defines the agent skills?

The skills are defined in **markdown files with YAML front-matter** named [`SKILL.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/SKILL.md). The front-matter contains metadata like `name`, `version`, and `triggers`, while the body contains the procedural steps and quiz content.

### How does the agent know to run a skill when I type `/find-your-level`?

After running [`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py), the agent creates a **manifest** that maps the trigger phrase `/find-your-level` to the file path `~/.claude/skills/find-your-level/SKILL.md`. When the agent parses your input and matches the slash-command, it loads and executes that specific skill file.

### Can I use these skills in Cursor if they are defined in the `.claude` directory?

Yes. The [`install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/install_skills.py) script copies the skill files to **both** `~/.claude/skills/` and `~/.cursor/skills/` directories. Because both agents use the same markdown schema, the skills work identically across Claude Code and Cursor.

### Where does `/check-understanding` get its questions from?

The skill generates questions dynamically by **parsing the lesson documents** located in the specific phase directory you specify. It extracts key concepts and code examples to create four conceptual and four practical multiple-choice questions relevant to that phase's content.