How Claude and Cursor Agent Skills Like `/find-your-level` Work in AI Engineering from Scratch

Claude and Cursor agent skills in the AI Engineering from Scratch curriculum operate as markdown-based instruction files that define interactive quizzes, scoring logic, and personalized learning paths, which agents execute through built-in tools like AskUserQuestion.

The rohitg00/ai-engineering-from-scratch repository implements a lightweight skill system that extends Claude and Cursor with curriculum-aware commands. These skills are not external plugins but self-contained markdown definitions stored in the repository, enabling the agents to run placement assessments and comprehension checks without calling external APIs.

What Are Agent Skills?

Agent skills are declarative markdown files with YAML front-matter that instruct the AI on how to conduct specific interactions. Located in .claude/skills/ and .cursor/skills/ directories, each skill defines trigger phrases, procedural steps, and output formats that the agent parses at runtime.

When you type a slash command like /find-your-level, the agent matches this against a local manifest, loads the corresponding SKILL.md file, and executes the defined workflow using native agent tools.

How the /find-your-level Skill Works

The placement assessment logic lives in .claude/skills/find-your-level/SKILL.md. This file contains the complete specification for diagnosing a learner's starting phase in the curriculum.

Skill Definition and Front-Matter Structure

The skill file begins with a YAML front-matter block (delimited by ---) that declares:

• Name and version: Identifies the skill for the manifest
• Trigger phrases: Includes /find-your-level and natural language variants like "where should I start?"
• Description: Explains the assessment purpose to the agent

Following the front-matter, the markdown body contains the procedural logic the agent follows.

Quiz Structure and Scoring Logic

The skill defines a 10-question assessment covering five knowledge areas:

1. Quiz content: Two questions per domain (Mathematics, Programming, Machine Learning, etc.)
2. Scoring: Each correct answer awards 1 point, totaling a maximum of 10 points
3. Phase mapping: Lines 73-80 of the skill file contain a Score-to-Entry-Point table that maps the raw score (0-10) to one of five starting phases in the curriculum

The Interactive Execution Flow

When triggered, the agent executes this sequence:

1. Command detection: The parser matches /find-your-level against the manifest entry pointing to ~/.claude/skills/find-your-level/SKILL.md
2. Skill loading: The agent reads the markdown file, parsing the quiz instructions and scoring rubric
3. Interactive questioning: Using the AskUserQuestion tool, the agent presents each question sequentially and records responses
4. Score computation: After the final question, the agent sums correct answers and consults the Score-to-Entry-Point mapping
5. Path generation: The agent constructs a personalized curriculum table (lines 102-138 in the skill file) that marks each phase as Skip, Review, or Do, pulling hour estimates from ROADMAP.md

# Conceptual execution flow as implemented by the agent runtime

skill_path = os.path.expanduser("~/.claude/skills/find-your-level/SKILL.md")
skill = load_skill(skill_path)  # Parses front-matter and procedural body

# The agent then implements this loop internally

score = 0
for question in skill.quiz_questions:
    answer = AskUserQuestion(question.text, options=question.options)
    if answer == question.correct:
        score += 1

starting_phase = map_score_to_phase(score)  # Uses lines 73-80 mapping

generate_learning_path(starting_phase)      # Builds table from lines 102-138

How the /check-understanding Skill Works

The comprehension verification skill, defined in .claude/skills/check-understanding/SKILL.md, operates differently by generating phase-specific quizzes rather than a fixed placement test.

• Phase parsing: Accepts either a numeric phase ID or a textual phase name (e.g., "Phase 2" or "Math Foundations")
• Content loading: Dynamically loads lesson documents from the specified phase directory
• Question generation: Creates eight multiple-choice questions (four conceptual, four practical) drawn directly from the phase content
• Assessment: Presents questions via AskUserQuestion, tracks the score, and recommends whether to proceed, review, or repeat the phase

Installing and Registering Skills

The repository includes scripts/install_skills.py to deploy skills to the agent's runtime environment:

# From scripts/install_skills.py - installation logic

import shutil
from pathlib import Path

def install_skills():
    # Source directories in the repo

    claude_skills = Path(".claude/skills/")
    cursor_skills = Path(".cursor/skills/")
    
    # Target directories in user home

    home_claude = Path.home() / ".claude" / "skills"
    home_cursor = Path.home() / ".cursor" / "skills"
    
    # Copy and update manifests

    if claude_skills.exists():
        shutil.copytree(claude_skills, home_claude, dirs_exist_ok=True)
        update_manifest(home_claude)
    
    if cursor_skills.exists():
        shutil.copytree(cursor_skills, home_cursor, dirs_exist_ok=True)
        update_manifest(home_cursor)

The script performs three critical functions:

1. Copies skill directories from the repository to ~/.claude/skills/ and ~/.cursor/skills/
2. Updates the manifest that maps slash-commands to specific SKILL.md file paths
3. Ensures runtime availability so the agent discovers the skills on startup

Cross-Compatibility Between Claude and Cursor

Both agents share an identical markdown schema, making skills interchangeable. The only variance is the installation path:

• Claude: Skills installed to ~/.claude/skills/
• Cursor: Skills installed to ~/.cursor/skills/

The install_skills.py script handles both locations simultaneously when present, ensuring curriculum consistency across different AI coding assistants.

Summary

• Claude and Cursor agent skills are markdown-based instruction files with YAML front-matter defining interactive behaviors.
• The /find-your-level skill in .claude/skills/find-your-level/SKILL.md implements a 10-question placement quiz with a score-to-phase mapping table (lines 73-80) and personalized path generation (lines 102-138).
• The /check-understanding skill generates dynamic phase-specific assessments using the AskUserQuestion tool.
• scripts/install_skills.py deploys skills to ~/.claude/skills/ and ~/.cursor/skills/, updating the command manifest so slash-commands resolve correctly.
• Both agents use the same skill format, enabling identical curriculum experiences across Claude and Cursor.

Frequently Asked Questions

How do I trigger the /find-your-level skill after installation?

Type /find-your-level in the agent chat interface, or use natural language triggers like "where should I start?" or "assess my level" defined in the skill's front-matter. The agent detects the command, loads the skill from ~/.claude/skills/find-your-level/SKILL.md, and begins the 10-question assessment.

Can I modify the quiz questions or scoring thresholds?

Yes. Edit .claude/skills/find-your-level/SKILL.md (or the copied version in ~/.claude/skills/) to change the question content or adjust the Score-to-Entry-Point table. The scoring logic is transparent markdown, allowing you to customize the 1-point-per-question rubric or remap score ranges to different starting phases.

Why does the skill reference ROADMAP.md for hour estimates?

The personalized path table generated at the end of the quiz needs accurate time estimates for each curriculum phase. The skill file instructs the agent to pull these hour values from the repository's ROADMAP.md, ensuring the final recommendation ("~55 hours across 12 phases") reflects the current curriculum structure.

Do these skills work with other AI agents besides Claude and Cursor?

The markdown-based skill system is designed to be portable. While the installation script specifically targets Claude and Cursor directories (~/.claude/, ~/.cursor/), any agent runtime that supports AskUserQuestion tools and markdown skill parsing—such as OpenClaw, Hermes, or Codex—can theoretically execute the same skill files by reading the front-matter instructions.

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