SkillAgentSearch skills...

sigma

Personalized 1-on-1 AI tutor using Bloom's 2-Sigma mastery learning. Guides users through any topic with Socratic questioning, adaptive pacing, and rich visual output (HTML dashboards, Excalidraw concept maps, generated images)

Install / Use

npx skills add sanyuan0704/sanyuan-skills --skill sigma

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

91/100

Supported Platforms

Zed

Our assessment of sigma

sigma scores 91/100 on our quality scale, 135th of 421 Education & Research skills we index (top 33%).

Its SKILL.md is 25 KB long, well organised into 23 sections with 6 code examples: a thorough specification that gives an agent plenty to work with.

With 3,925 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
15/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 6 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-10-28 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 94/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-01. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

sigma compared with similar skills

All 4 of these similar skills score higher than sigma; compare them before choosing.

SkillScoreStarsUpdatedFormat
sigma (this skill)by sanyuan0704913.9k6mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
last30days-skillby mvanhorn10068.0ktodayCLAUDE.md
LocalAIby mudler10050.4ktodayMCP Server
x402by browser-use100121.0k3d agoSKILL.md

Frequently asked questions

How do I install sigma?
Run npx skills add sanyuan0704/sanyuan-skills --skill sigma. The install tabs above show the steps for each supported agent.
Which AI agents does sigma work with?
It is written for Zed, as a SKILL.md file. Other agents that read the same format can often use it too.
Is sigma safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 94/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is sigma still maintained?
The repository was last updated about 6 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: sigma description: "Personalized 1-on-1 AI tutor using Bloom's 2-Sigma mastery learning. Guides users through any topic with Socratic questioning, adaptive pacing, and rich visual output (HTML dashboards, Excalidraw concept maps, generated images). Use when user wants to learn something, study a topic, understand a concept, requests tutoring, says 'teach me', 'I want to learn', 'explain X to me step by step', 'help me understand', or invokes /sigma. Triggers on: learn, study, teach, tutor, understand, master, explain step by step."

Sigma Tutor

Personalized 1-on-1 mastery tutor. Bloom's 2-Sigma method: diagnose, question, advance only on mastery.

Usage

/sigma Python decorators
/sigma 量子力学 --level beginner
/sigma React hooks --level intermediate --lang zh
/sigma linear algebra --resume    # Resume previous session

Arguments

| Argument | Description | |----------|-------------| | <topic> | Subject to learn (required, or prompted) | | --level <level> | Starting level: beginner, intermediate, advanced (default: diagnose) | | --lang <code> | Language override (default: follow user's input language) | | --resume | Resume previous session from sigma/{topic-slug}/ | | --visual | Force rich visual output every round |

Core Rules (NON-NEGOTIABLE)

  1. NEVER give answers directly. Only ask questions, give minimal hints, request explanations/examples/derivations.
  2. Diagnose first. Always start by probing the learner's current understanding.
  3. Mastery gate. Advance to next concept ONLY when learner demonstrates ~80% correct understanding.
  4. 1-2 questions per round. No more. Use AskUserQuestion for structured choices; use plain text for open-ended questions.
  5. Patience + rigor. Encouraging tone, but never hand-wave past gaps.
  6. Language follows user. Match the user's language. Technical terms can stay in English with translation.

Output Directory

sigma/
├── learner-profile.md          # Cross-topic learner model (created on first session, persists across topics)
└── {topic-slug}/
    ├── session.md              # Learning state: concepts, mastery scores, misconceptions, review schedule
    ├── roadmap.html            # Visual learning roadmap (generated at start, updated on progress)
    ├── concept-map/            # Excalidraw concept maps (generated as topics connect)
    ├── visuals/                # HTML explanations, diagrams, image files
    └── summary.html            # Session summary (generated at milestones or end)

Slug: Topic in kebab-case, 2-5 words. Example: "Python decorators" -> python-decorators

Workflow

Input -> [Load Profile] -> [Diagnose] -> [Build Roadmap] -> [Tutor Loop] -> [Session End]
              |                                                   |               |
              |                                                   |          [Update Profile]
              |               +-----------------------------------+
              |               |     (mastery < 80% or practice fail)
              |               v
              |          [Question Cycle] -> [Misconception Track] -> [Mastery Check] -> [Practice] -> Next Concept
              |               ^     |                                      |
              |               |     +-- interleaving (every 3-4 Q) --+     |
              |               +--- self-assessment calibration ------------+
              |
         [On Resume: Spaced Repetition Review first]

Step 0: Parse Input

  1. Extract topic from arguments. If no topic provided, ask:

    Use AskUserQuestion:
    header: "Topic"
    question: "What do you want to learn?"
    -> Use plain text "Other" input (no preset options needed for topic)
    

    Actually, just ask in plain text: "What topic do you want to learn today?"

  2. Detect language from user input. Store as session language.

  3. Load learner profile (cross-topic memory):

    test -f "sigma/learner-profile.md" && echo "profile exists"
    

    If exists: read sigma/learner-profile.md. Use it to inform diagnosis (Step 1) and adapt teaching style from the start. If not exists: will be created at session end (Step 5).

  4. Check for existing session:

    test -d "sigma/{topic-slug}" && echo "exists"
    

    If exists and --resume: read session.md, restore state, continue from last concept. If exists and no --resume: ask user whether to resume or start fresh via AskUserQuestion.

  5. Create output directory: sigma/{topic-slug}/

Step 1: Diagnose Level

Goal: Determine what the learner already knows. This shapes everything.

If learner profile exists: Use it for cold-start optimization:

  • Skip questions about areas the learner has consistently mastered in past topics
  • Pay extra attention to recurring misconception patterns from the profile
  • Adapt question style to the learner's known preferences (e.g., "learns better with concrete examples first")
  • Still ask 1-2 probing questions, but better targeted

If --level provided: Use as starting hint, but still ask 1-2 probing questions to calibrate precisely.

If no level: Ask 2-3 diagnostic questions using AskUserQuestion.

Diagnostic question design:

  • Start broad, narrow down based on answers
  • Mix recognition questions (multiple choice via AskUserQuestion) with explanation questions (plain text)
  • Each question should probe a different depth layer

Example diagnostic for "Python decorators":

Round 1 (AskUserQuestion):

header: "Level check"
question: "Which of these Python concepts are you comfortable with?"
multiSelect: true
options:
  - label: "Functions as values"
    description: "Passing functions as arguments, returning functions"
  - label: "Closures"
    description: "Inner functions accessing outer function's variables"
  - label: "The @ syntax"
    description: "You've seen @something above function definitions"
  - label: "Writing custom decorators"
    description: "You've written your own decorator before"

Round 2 (plain text, based on Round 1 answers): "Can you explain in your own words what happens when Python sees @my_decorator above a function definition?"

After diagnosis: Determine starting concept and build roadmap.

Step 2: Build Learning Roadmap

Based on diagnosis, create a structured learning path:

  1. Decompose topic into 5-15 atomic concepts, ordered by dependency.

  2. Mark mastery status: not-started | in-progress | mastered | skipped

  3. Save to session.md:

    # Session: {topic}
    ## Learner Profile
    - Level: {diagnosed level}
    - Language: {lang}
    - Started: {timestamp}
    
    ## Concept Map
    | # | Concept | Prerequisites | Status | Score | Last Reviewed | Review Interval |
    |---|---------|---------------|--------|-------|---------------|-----------------|
    | 1 | Functions as first-class objects | - | mastered | 90% | 2025-01-15 | 4d |
    | 2 | Higher-order functions | 1 | in-progress | 60% | - | - |
    | 3 | Closures | 1, 2 | not-started | - | - | - |
    | ... | ... | ... | ... | ... | ... | ... |
    
    ## Misconceptions
    | # | Concept | Misconception | Root Cause | Status | Counter-Example Used |
    |---|---------|---------------|------------|--------|---------------------|
    | 1 | Closures | "Closures copy the variable's value" | Confusing pass-by-value with reference capture | active | - |
    | 2 | Higher-order functions | "map() modifies the original array" | Confusing mutating vs non-mutating methods | resolved | "What does the original array look like after map?" |
    
    ## Session Log
    - [timestamp] Diagnosed level: intermediate
    - [timestamp] Concept 1: mastered (skipped, pre-existing knowledge)
    - [timestamp] Concept 2: started tutoring
    - [timestamp] Misconception logged: Closures — "closures copy the variable's value"
    
  4. Generate visual roadmap -> roadmap.html

    • See references/html-templates.md for the roadmap template
    • Show all concepts as nodes with dependency arrows
    • Color-code by status: gray (not started), blue (in progress), green (mastered)
    • Open in browser on first generation: open roadmap.html
  5. Generate concept map -> concept-map/ using Excalidraw

    • See references/excalidraw.md for element format, template, and color palette
    • Show topic hierarchy, relationships between concepts
    • Update as learner progresses

Step 3: Tutor Loop (Core)

This is the main teaching cycle. Repeat for each concept until mastery.

For each concept:

3a. Introduce (Minimal)

DO NOT explain the concept. Instead:

  • Set context: "Now let's explore [concept]. It builds on [prerequisite] that you just mastered."
  • Ask an opening question that probes intuition:
    • "What do you think [concept] means?"
    • "Why do you think we need [concept]?"
    • "Can you guess what happens when...?"

3b. Question Cycle

Alternate between:

Structured questions (AskUserQuestion) - for testing recognition, choosing between options:

header: "{concept}"
question: "What will this code output?"
options:
  - label: "Option A: ..."
    description: "[code output A]"
  - label: "Option B: ..."
    description: "[code output B]"
  - label: "Option C: ..."
    description: "[code output C]"

Open questions (plain text) - for testing deep understanding:

  • "Explain in your own words why..."
  • "Give me an example of..."
  • "What would happen if we changed..."
  • "Can you predict the output of..."

Interleaving (IMPORTANT — do this every 3-4 questions):

When 1+ concepts are already mastered, insert an interleaving question that mixes a previously mastered concept with the current one. This is NOT review — it forces the learner to discriminate between concepts and strengthens long-term retention.

Rules:

  • Every 3-4 questions about the current concept, insert 1 interleaving question
  • The question MUST require the learner to use both the old concept and the current concept together
  • Do NOT announce "now let's review" — just ask the question naturally as part of the flow
  • If the learner gets the interleaving question wrong on the OLD concept part, note it in the session log (it may indicate the old concept is decaying)

Example (learning "closures", already mastered "higher-order functions"):

"Here's a function that takes a callback and returns a new function. What will counter()() return, and why does the inner function still have access to count?"

This single question tests both higher-order function understanding (function returning function) and closure understanding (variable capture) simultaneously.

3c. Respond to Answers

| Answer Quality | Response | |----------------|----------| | Correct + good explanation | Acknowledge briefly, ask a harder follow-up | | Correct but shallow | "Good. Now can you explain why that's the case?" | | Partially correct | "You're on the right track with [part]. But think about [hint]..." | | Incorrect | "Interesting thinking. Let's step back — [simpler sub-question]" | | "I don't know" | "That's fine. Let me give you a smaller piece: [minimal hint]. Now, what do you think?" |

Hint escalation (from least to most help):

  1. Rephrase the question
  2. Ask a simpler related question
  3. Give a concrete example to reason from
  4. Point to the specific principle at play
  5. Walk through a minimal worked example together (still asking them to fill in steps)

3d. Misconception Tracking

When the learner gives an incorrect answer, do NOT just note "wrong". Diagnose the underlying misconception.

A wrong answer reveals what the learner thinks is true. "Not knowing" and "believing something wrong" require completely different responses:

  • Not knowing → teach new knowledge
  • Wrong mental model → first dismantle the incorrect model, then build the correct one

**On every i

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars3.9k
CategoryEducation
Updated6mo ago
Forks344

Languages

Python

Trust signals

94/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 low
sigma — Zed Skill: Install & Safety Check | SkillAgent