QuizMe

Adaptive tech quiz skill for OpenClaw. Asks one question at a time on any coding or CS topic: Python, JavaScript, SQL, system design, algorithms, networking, Git, Docker, APIs, and more. Includes code snippets where relevant. Difficulty adapts dynamically — harder after correct answers, easier after wrong ones. Uses a rolling question bank generated in batches (via GPT-4o-mini) so sessions are fast and token-efficient. Automatically graduates you to the next difficulty level when you hit 80% accuracy. Tracks your topics and progress across sessions. Trigger: /quizme, "quiz me on X", "teach me X", "test my knowledge of X", "I want to learn X", "start a quiz".

Overview

An adaptive, Socratic quiz skill for tech and coding topics. Asks one question at a time, confirms right/wrong after each answer with a brief explanation, and adjusts difficulty dynamically — harder after a correct answer, easier (or same) after a wrong one. Saves topics to ~/quizme/topics.json for persistence across sessions.

Supported Topic Areas

Area	Subtopics
Python	basics, OOP, async/await, exceptions, decorators
JavaScript	closures, promises, async/await, event loop
SQL	joins, indexes, window functions, query optimization
System design	caching, load balancing, databases, CAP theorem
Algorithms & data structures	big-O, trees, graphs, sorting
Networking	HTTP, TCP/IP, DNS, websockets
Git	branching, rebasing, conflicts, workflows
Docker / Kubernetes	containers, images, pods, services
APIs	REST, GraphQL, auth patterns (OAuth, JWT)
General CS concepts	memory, OS basics, compilers, concurrency

See references/topics.md for detailed per-topic concept lists and example questions at each difficulty level.

Workflow

Step 1 — Start every session by asking the topic

Always ask the user what they want to practice, even if a topic was passed inline. Show the saved list from ~/quizme/topics.json if it exists:

"What would you like to practice today?" [if topics exist] "Your saved topics: 1. Python async 2. SQL joins (or type a new topic)"

After topic confirmed, ask difficulty OR load current difficulty from ~/quizme/progress.json if the user has history with this topic:

"Your last difficulty for Python was intermediate — continue there? (yes / pick another)"

If no prior history, default to beginner or ask: "What difficulty? (beginner / intermediate / advanced)"

Step 2 — Initialize the bank if needed

Check ~/quizme/bank/{topic_slug}-{difficulty}.json where topic_slug is the topic lowercased with spaces/special chars replaced by hyphens:

• If the file is missing or has fewer than 3 unseen questions ("seen": false): run generate_bank.py to create/refill it.
  • First run (file missing): generate 20 questions (--count 20)
  • Refill (file exists but low on unseen): generate 10 questions (--count 10)
• Tell the user: "Generating questions for [topic] at [difficulty]..." while it runs.
• After generating, add the topic to ~/quizme/topics.json if not already present.

Run the script with:

python3 ~/.openclaw/workspace/skills/quizme/scripts/generate_bank.py "<topic>" <difficulty> --count <N>

Step 3 — Ask questions from bank

Pick a random unseen question ("seen": false) from the bank. After showing it, immediately set "seen": true on that question and save the bank file.

Question format rules:

• If "code" field is non-null: include the snippet in a fenced code block using the "language" value
• If "code" is null: plain question text only
• Always show all 4 options (A/B/C/D) from the "options" field
• One question per message — never show two at once

Question template (code topic)

**Question N** — [Topic] ([difficulty])

[question text]

```[language]
[code snippet]

A) ... B) ... C) ... D) ...

#### Question template (conceptual topic)

Question N — [Topic] ([difficulty])

[question text]

A) ... B) ... C) ... D) ...

### Step 4 — After each answer

1. Reveal correct/wrong + show the `"explanation"` from the bank question (2–3 sentences).
2. Update the bank question:
   - Increment `"seen_count"` by 1
   - If correct: increment `"correct_count"` by 1
3. Save the bank file.
4. **Check graduation:** Count all questions in this bank where `"seen_count" > 0`. If there are ≥ 15 such questions AND `(sum of correct_count / sum of seen_count) >= 0.80` → trigger graduation (Step 5).
5. **Check refill:** Count remaining unseen questions (`"seen": false`). If fewer than 5 remain → silently run `generate_bank.py --count 10` in the background to append more.
6. Ask the next question.

### Step 5 — Graduation

When graduation triggers:
- Announce: *"You've mastered [difficulty] [topic]! Moving up to [next level]."*
- Delete the old bank file (`~/quizme/bank/{slug}-{difficulty}.json`)
- Update `~/quizme/progress.json`: mark current difficulty as graduated with today's date, set `current_difficulty` to the next level
- Run `generate_bank.py` for the next difficulty (`--count 20`)
- Continue the session at the new difficulty

Difficulty order: **beginner → intermediate → advanced**

At **advanced**: no graduation. Just keep refilling the bank when unseen questions run low.

### Step 6 — End session

When the user says "stop", "quit", "done", or similar:
- Show summary: topic, questions answered this session, correct count, accuracy %
- Save session stats to `~/quizme/progress.json` (increment answered/correct counts for this topic+difficulty)

## Storage Layout

~/quizme/ ├── topics.json # { "topics": ["python async", "SQL joins"] } ├── progress.json # per-topic difficulty + stats └── bank/ ├── python-beginner.json ├── sql-joins-intermediate.json └── ... # only current difficulty per topic lives here

### progress.json format

```json
{
  "python": {
    "current_difficulty": "intermediate",
    "beginner": { "answered": 17, "correct": 14, "graduated": true, "graduated_at": "2026-05-22" },
    "intermediate": { "answered": 4, "correct": 3, "graduated": false }
  }
}

topics.json format

{ "topics": ["python async", "SQL joins", "system design"] }

• On first run, create the file if it doesn't exist.
• When a new topic is introduced, append it to the list and save.
• When showing saved topics, display them as a numbered list.

Hard Rules — Never Break These

1. Never ask two questions at once.
2. Never add a code snippet to a non-code topic (networking, algorithms theory, CS concepts).
3. Never reveal the answer before the user responds.
4. This skill is tech-only. If the user asks to be quizzed on a non-tech topic (history, cooking, etc.), politely decline and list the supported topic areas.
5. Always provide 4 multiple-choice options (A/B/C/D) — no open-ended questions.
6. Always explain after every answer, even when correct.

Difficulty Levels

Level	Description
Beginner	Core syntax, definitions, basic usage patterns
Intermediate	How things work under the hood, common patterns, tricky edge cases
Advanced	Performance, internals, architectural tradeoffs, subtle bugs

Resources

references/

• topics.md — Detailed per-topic concept coverage at each difficulty level, with example question ideas. Load this when generating questions to ensure appropriate concept selection.