| name | quiz-me |
| description | Interactive multiple-choice quiz on this repo's code. Run it with /quiz-me or "quiz me". |
| disable-model-invocation | true |
Quiz the user on this repository with multiple-choice questions grounded in the real code. Never quiz from memory: read the source first, then ask.
Setup
Parse the invocation for two optional arguments:
- Level: easy | medium | hard | expert | mixed (default mixed)
- Count: number of questions (default 10)
If no level was given, ask once ("Which level: easy, medium, hard, expert, or mixed?") and wait for the answer before the first question.
Before serving anything, build the question bank:
- Scan the repo layout (glob source files, read configs and build files).
- Read enough real files to cover every topic listed below with actual symbols, paths, and line numbers.
- Draft the questions offline. Do not show drafts, just start serving.
Topics to draw from in this repo: Spring core annotations and bean wiring, configuration classes and @Bean, JPA entities and relationships, transactions, Flyway and schema management, Kafka producers, listeners, and DLT, gRPC services and clients, GraphQL resolvers, Spring Cloud Gateway filters, profiles and externalized config, correlation IDs and MDC, testing setup.
Difficulty contract
- easy: what one annotation or keyword means where this repo uses it. Recall.
- medium: how two pieces interact, such as an annotation plus its runtime effect, or a producer matched against a consumer. Comprehension.
- hard: pitfalls and edge cases: proxy self-invocation, lazy-loading failure points, serializer mismatch, filter ordering. Analysis against specific lines.
- expert: internals and tradeoffs: flush timing versus listener threads, reactive context propagation, delivery semantics under retries, schema evolution. Judgment calls saved for seniors.
Mixed mode samples roughly 25% easy, 35% medium, 25% hard, 15% expert, shuffled.
Serving a question
Serve ONE question per turn as a FLASHCARD, then stop and wait:
❓ Q<rank>/<count> [easy] jpa
One-line question, plain language.
**A)** short option
**B)** short option
**C)** short option
**D)** short option
**E)** short option
Flashcard rules:
- Question fits on one line, conversational, no setup prose before it.
- Options are short phrases, one line each. No option paragraphs.
- No code blocks unless the code snippet IS the question (then show only the annotated lines).
- Skip the "Reply A-E" instruction every turn; state once at session start.
- Keep the whole card under ~10 lines so the pace feels rapid-fire.
Rules:
- Include E) only when a fifth genuinely strong option exists; four is the norm.
- Exactly one defensibly best answer. If two options could win, rewrite the question before serving.
- Distractors come from the codebase itself: real class names, real annotations, near-miss behaviors. No joke options.
- Shuffle which letter holds the answer across questions.
- No repeats within a session. No two consecutive questions from the same topic.
- Every question must be answerable from a specific file you have read. Know its path and line range before serving.
Grading
On each answer, reveal immediately:
- Correct: confirm in one line, then explain the why in 2-4 sentences citing
file:line.
- Wrong: give the right letter, explain why it wins AND why the picked option loses, citing
file:line.
Track a running tally split by level and show it after each reveal, like Score 3/5 (easy 2/2, medium 1/2, hard 0/1).
"skip" reveals the answer, counts as wrong, moves on. "why" gives a deeper explanation without advancing. "stop" jumps to the wrap-up.
Wrap-up
After the last question (or "stop"), post a final report:
- Total score, plus per-level and per-topic breakdown.
- The two weakest topics, each with a one-line pointer to the file worth rereading.
Then offer: another round at a different level, a deeper set on a weak topic, or done.
