exam-stack
/exam-stack
Układa z dużej puli egzaminów z przeszłości priorytetową stronę do nauki: częste typy zadań, punkty i rozwiązania pod każdą częścią.
- Autor
- OskarRabenda ↗
- Repozytorium
- exam-stack-skill ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 12
- Skrypty
- 3
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 3
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- 3 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: scripts/build.mjs, scripts/bundle.mjs, scripts/tally.mjs
Co robi i kiedy
Układa z dużej puli egzaminów z przeszłości priorytetową stronę do nauki: częste typy zadań, punkty i rozwiązania pod każdą częścią.
Wyzwalacze z opisu
Oryginalny opis (EN)
Turn a large pool of past written exams into a prioritized, interactive study page (an "exam stack"). It counts which question types recur across the papers, ranks them by points for the time they take, and gives each one a solving recipe, what graders give points for, and real past-exam questions with the answer directly under every part, a tickable rubric for self-scoring, and rounds the student can restart. Use this whenever a student has many past exam papers and wants to prepare from them, asks what keeps coming back on an exam, wants a study plan, practice set or priority list for a writ
Jak działa
- Scope
- Running from a link (Claude or ChatGPT in the browser, nothing installed)
- Phases
- Principles
- Updating an existing stack
Podgląd SKILL.md
---
name: exam-stack
description: Turn a large pool of past written exams into a prioritized, interactive study page (an "exam stack"). It counts which question types recur across the papers, ranks them by points for the time they take, and gives each one a solving recipe, what graders give points for, and real past-exam questions with the answer directly under every part, a tickable rubric for self-scoring, and rounds the student can restart. Use this whenever a student has many past exam papers and wants to prepare from them, asks what keeps coming back on an exam, wants a study plan, practice set or priority list for a written exam, or shares a folder of past papers, solutions or rubrics and asks for help studying, even if they never say "stack".
---
# Exam stack
> **Use it without installing anything (Claude or ChatGPT website).** Start a new chat, attach your past exams (and solutions if you have them), and paste this:
>
> ```
> Use the "exam-stack" skill. Read its instructions and follow them step by step:
> https://raw.githubusercontent.com/OskarRabenda/exam-stack-skill/main/skills/exam-stack/SKILL.md
>
> My course: [course name]
> Exam date and time: [date, time]
> Study time I have: [about N hours]
> My past exams are attached.
> If you can't open that link, don't guess: tell me, and I'll attach the file instead.
> ```
>
> **If your AI says it can't open the link:** open <https://raw.githubusercontent.com/OskarRabenda/exam-stack-skill/main/exam-stack-all-in-one.md> in your browser, press **Ctrl+S** (Mac: **Cmd+S**) to save it, attach the saved file to the same chat, and write: *"Here is the file. Follow it."*
An exam stack is one HTML page that answers a student's question: *with the time I have left, what should I practise, in what order, with which real exam questions, and how will it be graded?*
It shows how the exam is graded, then a ranked list of **task cards**. A task is one recurring *kind* of question ("compute an inverse with the extended Euclidean algorithm", "True/False on definitions", "explain why TCP needs a three-way handshake"). Each card holds:
- why it sits at this rank
- **what graders reward** on this kind of question
- a short **recipe** for answering it
- real past-exam questions where **every part has its answer directly under it**, with a **rubric checklist** the student ticks to score themselves
Cards move to a Done pile and can always be put back. **Restart the stack** starts a new round (all cards, or only those scored under 70%), and earlier rounds stay in the history.
The value is in two things a student can't easily do alone: **an honest ranking** counted from many papers, and **trustworthy answers with the real point split**. Spend your effort there. The page is a template.
## Scope
- **Written exams only**, with a **large pool of past papers** (as a rule of thumb, at least 4; more is better). The ranking is a count, and a count over two papers isn't one.
- Not for oral exams, lab or practical exams, take-home projects, or courses with no past papers. If that's the situation, say so and stop rather than building something that looks authoritative but isn't.
## Running from a link (Claude or ChatGPT in the browser, nothing installed)
If you were pointed at this file by URL, or were given `exam-stack-all-in-one.md` as an attachment, instead of having the skill installed, everything still works. (In the all-in-one file, every reference and the template are sections further down the same file, so use those instead of links.)
- **The other files** live next to this one. Open them by adding the path to `https://raw.githubusercontent.com/OskarRabenda/exam-stack-skill/main/skills/exam-stack/`, e.g. `…/references/stack-json.md` or `…/assets/template.html`. Read a reference when a phase tells you to.
- **Inputs** are the files attached to the chat instead of a folder. **Outputs** are files you hand back (a download, or an Artifact / canvas) instead of files saved to a folder.
- **Counting (phase 3):** run `scripts/tally.mjs` if you can run Node with internet access. Otherwise do the same count in Python or by hand: papers on, typical points, share of all points with every paper normalized to 100, year last seen.
- **Building (phase 6):** if you can run Node, fetch `scripts/build.mjs` and `assets/template.html` and run the build. If not, build it yourself:
1. Fetch `assets/template.html`.
2. Inside every `\( … \)` and `\[ … \]` in your data, replace `<` with `<`.
3. Serialize `stack.json` and replace `</` with `<\/`.
4. Put the result in place of `/*__STACK__*/` in the template.
5. Check yourself what the build would check: unique ids, every part has a question and an answer under it, and no True/False block bundled into one part.
Images can't be inlined this way, so describe a figure in words or skip that exercise.
- **Delivering:** in Claude, publish the finished page as an HTML Artifact. In ChatGPT, give it as a downloadable `exam-stack.html`. The page loads its fonts and MathJax from the web, and keeps progress in the student's browser.
## Phases
### 0. Gate: is there a pool?
List the past papers you can find (and their solutions or rubrics). If there are fewer than about 4 written papers, tell the user the ranking would be guesswork and ask whether they can find more before going on.
### 1. Gather and ask
Find these before asking anything; they're usually in the folder the user points you to:
- the past papers, plus official solutions, rubrics and grading notes
- lecture notes, to write recipes in the course's own notation
- the student's cheat sheet, if one is allowed (recipes must match it word for word)
- the exam date and time, and the student's coursework points if the pass rule depends on them
Then ask, in one batch, only what you couldn't find: how much study time is left (a rough number is fine), which topics they already know, and confirm that exercises come only from real past papers.
### 2. Exam profile: how is it graded?
Read the cover pages and instructions of the papers and write down how the exam is graded: duration, total points, allowed aids, sections with **minimum scores**, **negative marking**, **choice questions**, answering rules ("justify every answer") and the pass rule. These change the strategy, not just the header. A section minimum can force a low-value card up, negative marking needs a "when to leave it blank" line, and a closed-book exam means recipes must be memorized. Read `references/exam-profile.md`.
### 3. Tally and rank
Go through every paper, sub-question by sub-question, and record a tally row: paper, question number, points, **task type** (the skill being tested, not the chapter), and **kind** (calculation, explain, recall, proof, multiple-choice, true-false). Whenever a rubric or solution shows how points were split, note that too; you'll need it in phase 5.
Then let the script do the counting:
```bash
node <skill-dir>/scripts/tally.mjs tally.csv --minutes minutes.json --md recurring-exam-questions.md
```
It reports, per task: papers it appeared on, typical points, share of all points (papers normalized to 100), the year last seen, and, with rough minutes per task, expected points per hour. Read `references/frequency-research.md` for the tally format and edge cases.
Use the table to set the stack order, then adjust it by judgment where the profile demands (section minimums, prerequisites a task builds on, topics that recently dropped out of the syllabus). Aim for roughly 12–20 tasks. Fewer and cards get too broad for one recipe; more and the student can't finish. Minutes are a rough estimate; don't spend time refining them.
Save `recurring-exam-questions.md` in the user's folder. The student will reread it.
### 4. Write the cards
For each task, set `kind`, `why`, `graders` and `recipe` (and `after` if it builds on another task).
- **`graders`, what graders reward:** 1–3 sentences on what earns and loses points on *this kind* of question, from official rubrics where they exist and otherwise from patterns across the papers' solutions. For example: "Each division step must be verified; a correct inverse without the checks loses 3 of 10." This is often the most useful line on the card.
- **Recipe:** 3–6 numbered steps the student follows *in the exam*, in the course's notation, including the trap that costs points. If the student has a cheat sheet, copy its text exactly and set `ref`. If they're allowed one but don't have one, offer to write it first and derive the recipes from it.
- **Kind-specific:** true-false and multiple-choice cards need a recipe for deciding *and* for when to leave it blank (if wrong answers cost points). Explain and proof cards need an answer *structure* (what a full-marks answer contains), since there is no calculation to follow.
### 5. Exercises: answers under every part
Per task, pick **2–4 real past-paper questions**, newest first, varied across years. For each one:
1. **Split it into parts exactly as the paper does.** Every sub-question, every True/False statement, every multiple-choice item is its own part with its own answer directly beneath it. A block of 16 True/False statements is one exercise with 16 parts. A shared stem (definitions, a given table, a figure) goes in `intro`. This matters: a student checks one answer at a time, and answers collected at the end are unusable.
2. **Transcribe faithfully**, including hints, given tables and figures (save figures as image files and reference them; the build inlines them).
3. **Write the solution** in the style the grader rewards (justification lines, intermediate steps), and for true-false / multiple-choice give the short `answer` plus a one-line reason.
4. **Write the rubric** whenever you have the information: one item per thing the grader gives points for, with its points, marked `official` (from a rubric or grading notes) or `inferred` (your reading of how this course grades). Any part worth more than 1 point should have at least an inferred rubric. Read `references/grading.md`.
5. **Verify and label the source** (`verified`):
- `official`: taken from an official solution
- `recomputed`: every number checked with a quick script
- `reasoned`: an explanation or argument that can't be recomputed
A wrong answer teaches a mistake the night before the exam. Recompute every calculation. For `reasoned` answers, check them against the lecture notes and keep them short and sourced.
For a big course, split phases 3–5 across subagents (e.g. one per part of the course). Give each one the task list, the paper paths and `references/stack-json.md`, have it verify its own numbers, then spot-check their output yourself.
### 6. Build and check
Write everything to one `stack.json` (format and full example: `references/stack-json.md`, `assets/example-stack.json`), then:
```bash
node <skill-dir>/scripts/build.mjs path/to/stack.json path/to/exam-stack.html
```
The build validates the data, inlines images, makes math HTML-safe and embeds everything in `assets/template.html`. Fix every error, and read the warnings. "Question and solution both hold a list" almost always means statements that should be separate parts. "No rubric" means the grading information is missing.
Open the page and check: the profile reads right, the top card opens, the math renders, every part's answer opens right under it, ticking rubric items updates the score, restart works, and it fits a phone screen.
**Deliver it** in the most durable way available. Publish it as a hosted page if you can (e.g. a claude.ai Artifact; declare per-user storage if offered, since the template syncs progress through `claude.use("db")` / `claude.use("user")` when available). Otherwise save `exam-stack.html` in the user's folder. It works as a local file, with progress kept in the browser.
### 7. Wrap up
- Keep `stack.json`, `tally.csv`, the built page and `recurring-exam-questions.md` in the user's folder. Changes later are an edit to `stack.json` plus a rebuild.
- Give a **rough** expected score: the share of points the cards cover × a realistic success rate (say 75–85% for practised tasks), turned into a grade using the profile's pass rule. Say how far down the stack the student must get to pass with a margin. Present it as an estimate that assumes the next paper looks like the past ones, not a promise.
## Principles
- **Real exam questions only.** Never invent exercises in the exam's style unless the student asks, and then label them clearly.
- **Every answer sits under its own question.**
- **Make grading explicit.** If you know what graders give points for, it goes on the card (`graders`) and on the part (`rubric`), labelled official or inferred.
- **Nothing is deleted.** Done cards go to the pile, restarts keep the history, and a card the student wants gone goes to the pile.
- **Verified over complete.** Two verified exercises beat four unchecked ones; say which answers are reasoned rather than recomputed.
- **The student's material is authoritative.** Their cheat sheet and the course's notation win over yours.
## Updating an existing stack
Edit `stack.json` and rebuild; never hand-edit the built HTML. Keep task `id`s and exercise `id`s stable, since saved progress is keyed by them. Add new exercises with new ids rather than reusing old ones. If the stack was published as a hosted page, republish to the same address so the student's link and progress survive.
Pliki w paczce (12)
- SKILL.md 13 KB
- assets/example-stack.json 10 KB
- assets/example-tally.csv 1 KB
- assets/template.html 40 KB
- assets/figures/unit-square.svg 1 KB
- references/exam-profile.md 3 KB
- references/frequency-research.md 4 KB
- references/grading.md 4 KB
- references/stack-json.md 6 KB
- scripts/build.mjs 10 KB
- scripts/bundle.mjs 2 KB
- scripts/tally.mjs 6 KB
Wersje
W bazie nie ma innych skilli o nazwie exam-stack.
Migawka bazy z 13.11.2026 · wersja paczki f166f22bd433 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 82mimir-study
Prowadzi sesję nauki do egzaminu: krótką lekcję z następnego tematu, pytania praktyczne albo powtórkę zadań z poprzednich egzaminów. - 100exam-coach
Przygotowuje do egzaminu na podstawie materiałów studenta: diagnozuje słabe punkty, buduje quizy, testy i plan nauki. - 90exam-prep
Buduje zestaw do przygotowania do egzaminu z dawnych testów: mapę tematów, nowe zadania z rozwiązaniami, fiszki, próbny egzamin i plan powtórek. - 100exam-study-coach
Zamienia sylabus, notatki i pytania z lat ubiegłych w plan nauki z fiszkami, quizami, sprawdzaniem odpowiedzi i śledzeniem postępów. - 90exammind
Prowadzi adaptacyjnego trenera do egzaminów uniwersyteckich: plan nauki, quizy, fiszki, próbny egzamin i interaktywną aplikację z materiałów kursu. - 90exam-prep
Zamienia notatki, slajdy lub rozdział podręcznika w próbny egzamin z kluczem odpowiedzi, a potem sprawdza odpowiedzi i wyjaśnia błędy.