Agent skill

Quiz Me

by jellydn in jellydn/my-ai-tools

Verify understanding after implementation with targeted quizzes

MITAuto-check passedEducation

Install Quiz Me

skills CLI
$ npx skills add jellydn/my-ai-tools --skill quiz-me -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jellydn/my-ai-tools quiz-me --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jellydn/my-ai-tools.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/quiz-me .claude/skills/quiz-me && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
quiz-me
GitHub stars
123
Token cost
~2.6k tokens
SKILL.md length
695 words
Files
1
Skills in repo
33
Repo updated
First seen
Licence
MIT

At a glance

Verify understanding after implementation with targeted quizzes

  • Works in 5 steps: Scope the Quiz → Generate Questions → Conduct Quiz (One Question at a Time) → …
  • Tasks that involve Quizzes and assessments
  • SKILL.md covers When to Use, What It Does, How to Execute and Question Templates (Mapped to…, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Quiz Me is an agent skill from jellydn/my-ai-tools. Verify understanding after implementation with targeted quizzes

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: cline, claude, opencode, amp, codex, gemini, cursor, pi

It sits in Education, covering Quizzes and assessments. The repository describes itself as: Comprehensive configuration management for AI coding tools - Replicate my complete setup for Claude Code, OpenCode, Amp, Li, Codex and Claude Code Switch with custom… The licence is MIT.

When your agent uses it

  • Tasks that involve Quizzes and assessments

Example prompts

  • “/quiz-me”

Requirements

  • Compatibility (from SKILL.md): cline, claude, opencode, amp, codex, gemini, cursor, pi

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Scope the Quiz
  2. Generate Questions
  3. Conduct Quiz (One Question at a Time)
  4. Review Answers
  5. Summarise Results

What it can do on your machine

Read from SKILL.md and the folder at commit 62c9227. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    cline, claude, opencode, amp, codex, gemini, cursor, pi

    From compatibility in the SKILL.md frontmatter.

Context cost

Quiz Me loads about 2.6k tokens when it runs. Until then it costs about 18 tokens; SKILL.md has 695 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~18
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jellydn/my-ai-tools at commit 62c9227, republished under its MIT licence (© jellydn). 695 words, ~2,641 tokens.

Download SKILL.mdSave it as .claude/skills/quiz-me/SKILL.md (or your agent's skills folder).
name
quiz-me
description
Verify understanding after implementation with targeted quizzes
compatibility
cline, claude, opencode, amp, codex, gemini, cursor, pi
license
MIT
hint
Use after completing complex work to verify understanding
user-invocable
true

Quiz Me

When to Use

Use this skill after implementation when:

  • You've completed a complex feature
  • Need to write a PR description
  • Want to verify understanding of changes
  • About to present work to team
  • Ensuring you stay "in the loop" with agent work

What It Does

The agent generates a quiz about the implementation to verify your understanding. This helps you:

  • Identify gaps in your knowledge
  • Prepare for code review discussions
  • Write better PR descriptions
  • Stay engaged with increasingly capable agents

How to Execute

Step 1: Scope the Quiz

Determine what to test:

  • Core architectural decisions
  • Key implementation details
  • Edge cases and error handling
  • Integration points
  • Trade-offs made
Step 2: Generate Questions

Create questions across difficulty levels:

Level 1 - Recall (What):

  • What did we implement?
  • What files were changed?
  • What are the main components?

Level 2 - Understanding (Why):

  • Why did we choose this approach?
  • Why not use [alternative]?
  • What problem does this solve?

Level 3 - Application (How):

  • How would you explain this to a reviewer?
  • How does this integrate with existing code?
  • How would you debug an issue here?

Level 4 - Analysis (Implications):

  • What are the trade-offs?
  • What could go wrong?
  • What would you change if requirements changed?
Step 3: Conduct Quiz (One Question at a Time)

Use the ask_user_question tool for each quiz question. Ask one question at a time — present it, wait for the answer, provide feedback, then move to the next. This makes the quiz feel like a conversation, not a test.

Flow for each question:

  1. Ask using ask_user_question with the question and options
  2. Read the answer the user selected or typed
  3. Provide feedback: tell them the correct answer, explain why, link to code
  4. Track correctness mentally (or note it)
  5. Proceed to the next question

Guidelines for using ask_user_question:

  • Set header to a short label (max 16 chars) like "Architecture", "Trade-offs", "Edge Cases"
  • Write a clear question with context and any hint references
  • Provide 2-4 concrete options — concise label (1-5 words) with descriptive description
  • After the user answers, give the correct answer with explanation and code references
Step 4: Review Answers

After each question response:

  • If correct: Confirm and reinforce with additional context
  • If incorrect: Gently correct, explain why, point to the relevant code/commit
  • If open-ended: Evaluate against expected key points, fill in gaps
Step 5: Summarise Results

After all questions are answered:

  • Report overall understanding level
  • Highlight strong areas
  • Flag areas to review with code references
  • Extract PR description material

Question Templates (Mapped to ask_user_question)

Multiple Choice — Architectural Decision
// Ask one at a time
ask_user_question(questions: [{
  header: "Architecture",
  question: "Why did we use GitHub App Installation flow instead of OAuth for this integration? (Hint: check auth/github/installation.ts for the decision)",
  options: [
    {
      label: "OAuth is deprecated",
      description: "GitHub still supports OAuth, so this isn't the reason"
    },
    {
      label: "Org-level access",
      description: "Installation flow provides org-level access — OAuth Apps can't access org repos"
    },
    {
      label: "Easier to implement",
      description: "Installation flow is actually more complex to set up than basic OAuth"
    }
  ]
}])

// After answer — provide feedback:
// "Correct! OAuth Apps can't access organization repositories, which is a GitHub limitation.
// Installation tokens authenticate as the app installation, giving org-level scope.
// See: auth/github/installation.ts:42-58"
Show full SKILL.md (277 more words)Show less
Fill in the Blank (using open-ended)
ask_user_question(questions: [{
  header: "Implementation",
  question: "What are the token lifespans in our GitHub auth? Fill in:\n- User OAuth tokens last: ______\n- Installation tokens last: ______\n- We cache installation tokens for: ______\n(Hint: check auth/github/token-cache.ts)",
  options: [
    {
      label: "6mo / 1hr / 55min",
      description: "User OAuth=6 months, Installation tokens=1 hour, Cache TTL=55 minutes (5 min buffer)"
    },
    {
      label: "1yr / 8hr / 7hr",
      description: "Incorrect — installation tokens only last 1 hour, we need a 5-minute buffer before expiry"
    },
    {
      label: "Permanent / 24hr / 23hr",
      description: "Incorrect — GitHub installation tokens have a 1-hour expiry, not 24 hours"
    }
  ]
}])
Trade-off Analysis
ask_user_question(questions: [{
  header: "Trade-offs",
  question: "What's the main trade-off of our token caching strategy? We cache installation tokens with a 55-minute TTL.",
  options: [
    {
      label: "Speed vs staleness",
      description: "Correct — caching avoids rate limits (5000/hr) but a token could be stale for up to 5 minutes before natural expiry"
    },
    {
      label: "Memory vs latency",
      description: "The token cache is small (Redis, key pattern github:install:{id}:token) — memory isn't the constraint here"
    },
    {
      label: "Security vs simplicity",
      description: "Tokens are encrypted in Redis — security wasn't the trade-off driver for the TTL decision"
    }
  ]
}])
Edge Case Question
ask_user_question(questions: [{
  header: "Edge Cases",
  question: "What happens when a user uninstalls the GitHub App? How does our system respond?",
  options: [
    {
      label: "Hard delete record",
      description: "We soft delete instead to preserve audit trail and cascading session cleanup"
    },
    {
      label: "Soft delete + audit",
      description: "Correct — we soft delete the installation record and cascade to invalidate all user sessions, preserving the audit trail"
    },
    {
      label: "Nothing, tokens work",
      description: "Incorrect — when uninstalled, tokens immediately stop working. We must clean up sessions"
    }
  ]
}])
Code Reading Question
ask_user_question(questions: [{
  header: "Code Reading",
  question: "In the token refresh logic, why do we compare the cached token's expiry against a 55-minute threshold instead of the full 60 minutes?",
  options: [
    {
      label: "5-min safety buffer",
      description: "Correct! The 5-minute buffer prevents edge-case race conditions where a token expires between the cache check and the API call"
    },
    {
      label: "Rate limit overhead",
      description: "Rate limits are 5000/hr — the buffer isn't about rate limits, it's about preventing stale token usage"
    },
    {
      label: "Clock drift compensation",
      description: "While clock drift is a real concern, the primary reason is preventing token expiry during the request window"
    }
  ]
}])

Complete Quiz Interaction Flow

For a typical 4-6 question quiz, the flow looks like:

1. Agent: "Let me quiz you on the GitHub OAuth implementation.
   I'll ask one question at a time and give feedback after each."

2. ask_user_question → Q1 (Architecture question)
   User answers
   Agent feedback: "Correct! ... See auth/github/installation.ts:42"

3. ask_user_question → Q2 (Implementation question)
   User answers
   Agent feedback: "Almost — the cache TTL is 55 minutes, not 50..."

4. ask_user_question → Q3 (Edge case question)
   User answers
   Agent feedback: "Right!..."

5. ask_user_question → Q4 (Trade-off question)
   User answers
   Agent feedback: "Good analysis..."

6. Agent: "Here's your summary:
   - Strong on architecture decisions
   - Review token caching details (auth/github/token-cache.ts)
   - PR description material from Q1 and Q4..."

Best Practices

  1. One question per call: Always use ask_user_question with a single-question array. Never batch questions.
  2. Give feedback immediately: After each answer, confirm or correct with code references.
  3. Match complexity: Quiz difficulty should match implementation complexity.
  4. Test reasoning: Don't just ask "what", ask "why" and "how".
  5. Include context: Reference specific code/commits for verification.
  6. Provide hints: Include hints in the question text (not as tool hints, just inline).
  7. Wrong-answer options are educational: Each incorrect option's description should explain why it's wrong.
  8. Limit to 4-7 questions: Too many exhausts. Quality over quantity.

Integration with Other Skills

  • After Implementation: Always follow complex work with quiz
  • Before PR: Use quiz results to write description
  • With Implementation Log: Quiz questions based on logged decisions
  • For Documentation: Questions reveal what needs better docs

Success Criteria

A good quiz:

  • Tests understanding at multiple levels (recall → analysis)
  • Uses ask_user_question for focused, one-at-a-time questioning
  • Provides immediate feedback with code references after each answer
  • Reveals gaps in knowledge
  • Helps you articulate decisions
  • Prepares you for code review
  • Takes 5-15 minutes to complete
  • Results in better PR description
  • Identifies documentation needs

Common Pitfalls

  • Too easy: Only testing recall ("what did we do?")
  • Too hard: Testing minutiae not worth remembering
  • No feedback: User doesn't learn from wrong answers
  • No context: Questions without code references
  • Too long: Exhausting instead of enlightening
  • Batching questions: Asking multiple questions at once defeats the one-at-a-time flow

Output Format

Summary After Quiz
markdown
# Quiz Results: [Feature Name]

## Strong Areas
- [Area 1]: Solid understanding of X
- [Area 2]: Clear grasp of Y

## Areas to Review
- [Area 1]: Unclear on Z, review [file.ts:123]
- [Area 2]: Missing context on W, see [commit abc123]

## Recommended Actions
- [ ] Review [specific code section]
- [ ] Read [specific documentation]
- [ ] Discuss [specific decision] with team

## PR Description Material
Based on your answers, include in PR:
- [Key point 1 from quiz]
- [Key point 2 from quiz]
- [Trade-off explanation from Qx]

The quiz becomes your PR description outline.

© jellydn, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/quiz-me of jellydn/my-ai-tools.

Open the folder on GitHubat commit 62c9227

Compare with similar skills

Quiz Me next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Quiz Me compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Quiz Me this skilljellydn/my-ai-tools123—~2.6kAutomated safety check: PassMIT
DeepTutor CLIHKUDS/DeepTutor41k—~2.8kAutomated safety check: PassApache-2.0
AI Engineering Placement Quizrohitg00/ai-engineering-from-scratch67k—~2kAutomated safety check: PassMIT
Codebase to Coursezarazhangrui/codebase-to-course5.7k—~4.4kAutomated safety check: PassNone
AI Engineering Phase Quizrohitg00/ai-engineering-from-scratch67k—~2.1kAutomated safety check: PassMIT
Scholar EvaluationK-Dense-AI/claude-scientific-writer2.4k2 repos~2.9kAutomated safety check: NotesMIT

Similar skills

  • DeepTutor CLI

    HKUDS/DeepTutor

    Teaches the agent to set up and run DeepTutor from the command line: chat and capabilities, knowledge bases, partners, memory, sessions, notebooks and the server or Web app.

    41k GitHub stars~2.8k tokensUpdated 3 days ago
    EducationAuto-check passed
  • AI Engineering Placement Quiz

    rohitg00/ai-engineering-from-scratch

    Runs a 10-question quiz across five areas to place a learner in the AI Engineering from Scratch curriculum, so they skip what they already know.

    67k GitHub stars~2k tokensUpdated today
    EducationAuto-check passed
  • Codebase to Course

    zarazhangrui/codebase-to-course

    Turns a codebase into an interactive single-page HTML course for non-technical learners, with scroll modules, animated diagrams, quizzes and plain-English code translations.

    5.7k GitHub stars~4.4k tokensUpdated 6 mo ago
    EducationAuto-check passed
  • AI Engineering Phase Quiz

    rohitg00/ai-engineering-from-scratch

    Quizzes you on a completed phase of the AI Engineering from Scratch course, taking a phase number or name and mapping it to that phase's directory.

    67k GitHub stars~2.1k tokensUpdated today
    EducationAuto-check passed
  • Scholar Evaluation

    K-Dense-AI/claude-scientific-writer

    Provide qualitative-first, evidence-traceable developmental review of scholarly works and audit low-stakes research-assessment rubrics with optional local quality controls.

    2.4k GitHub starsUsed in 2 repos~2.9k tokens
    EducationAuto-check: notes
  • Evaluation

    guanyang/open-agent-hub

    This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and…

    977 GitHub starsUsed in 2 repos~4.2k tokens
    EducationAuto-check passed

More from jellydn/my-ai-tools

All 33 skills in this repo
  • Babysit PR

    jellydn/my-ai-tools

    A skill your agent uses when monitoring an open GitHub PR for CI failures, review feedback, mergeability, and safe retries or fixes.

    123 GitHub stars~4.1k tokensUpdated yesterday
    Auto-check passed
  • Visual PR

    jellydn/my-ai-tools

    Posts a concise visual outline as a GitHub pull request comment.

    123 GitHub stars~764 tokensUpdated yesterday
    Auto-check passed
  • Qmd Knowledge

    jellydn/my-ai-tools

    Manage project knowledge with qmd — captures learnings, decisions, and conventions

    123 GitHub stars~2.1k tokensUpdated yesterday
    Auto-check passed
  • Prd

    jellydn/my-ai-tools

    Generate Product Requirements Documents from feature ideas — plans specs and requirements

    123 GitHub starsUsed in 4 repos~1.8k tokens
    Auto-check passed
  • Capability Experiments

    jellydn/my-ai-tools

    Build an interactive report or experiment when the user asks to explore model capabilities.

    123 GitHub stars~2k tokensUpdated yesterday
    Auto-check passed
  • PR Review

    jellydn/my-ai-tools

    Fix PR review comments by implementing requested changes. An agent skill from jellydn/my-ai-tools.

    123 GitHub stars~1.1k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Quiz Me

What does Quiz Me do?

Verify understanding after implementation with targeted quizzes. Quiz Me is an agent skill from jellydn/my-ai-tools.

When should I use Quiz Me?

Quiz Me fits situations like: tasks that involve Quizzes and assessments.

How do I install Quiz Me in Claude Code?

Run `npx skills add jellydn/my-ai-tools --skill quiz-me -a claude-code`. Or copy the skill folder (skills/quiz-me in jellydn/my-ai-tools) into .claude/skills/quiz-me in your project. Claude Code loads it when a task matches its description.

How do I install Quiz Me in Codex?

Run `npx skills add jellydn/my-ai-tools --skill quiz-me -a codex`. Or copy the skill folder (skills/quiz-me in jellydn/my-ai-tools) into .agents/skills/quiz-me in your project. Codex loads it when a task matches its description.

Can I use Quiz Me in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jellydn/my-ai-tools --skill quiz-me -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/quiz-me, .gemini/skills/quiz-me, .github/skills/quiz-me and .opencode/skills/quiz-me in your project.

What does Quiz Me need to run?

SKILL.md names no scripts, command-line tools or credentials: Quiz Me is instructions for the agent only. Compatibility (from SKILL.md): cline, claude, opencode, amp, codex, gemini, cursor, pi.

Does Quiz Me access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Quiz Me safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Quiz Me use?

Quiz Me is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Quiz Me use?

About 2.6k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Quiz Me?

Skills that share tags, products or a category with Quiz Me: DeepTutor CLI (HKUDS/DeepTutor, 41k stars), AI Engineering Placement Quiz (rohitg00/ai-engineering-from-scratch, 67k stars), Codebase to Course (zarazhangrui/codebase-to-course, 5.7k stars) and AI Engineering Phase Quiz (rohitg00/ai-engineering-from-scratch, 67k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Quiz Me?

jellydn (a GitHub user) maintains it in jellydn/my-ai-tools, which has 123 GitHub stars. The repository holds 33 skills in this directory. The repository was last updated on October 10, 2026.

Source: jellydn/my-ai-tools on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.