Gameplay mechanics

Items stream past; tap when one IS the named target, withhold on everything else.

• wears
• checkpoint officer
• scanner operator
• spotter
• copy editor on deadline
• wildlife photographer

The loop

A target NAME is fixed at the top of the screen. Items enter, cross and exit on a timer the player does not control; each is a decision made by acting or declining, and it leaves either way. The name rotates between rounds, so the player is matching against a moving exemplar rather than memorising one shape.

Consequence — what the fiction must deliver

Fuel, not points. A false identification burns more than a miss, because waving through the wrong vehicle is worse than hesitating — the scoring asymmetry is the teaching. Feedback is the gauge and the streak multiplier, both permanently visible, neither of them a verdict on the player.

Teaches well / badly

Fast identity matching and discrimination against near-twins — the pictogram known by shape before it is read. Teaches badly anything needing two things held in mind, or any judgment improved by a second look, since the mechanic punishes the second look.

Becomes a worksheet when

It becomes a worksheet the moment the target stops rotating. Fix the name for a whole session and the player pattern-matches one shape, drilling a single item fast while learning nothing about the other forty-nine. The tell is a rising streak with a flat error profile across concepts.

One unit of content

One item with an identity — a sign, a word, a construction — that either answers to the current target name or does not.

Required fields

id
display — the image or string shown as it crosses
concept — the scoring key; several items can share one, which is the point
criterion_keys — every target name this item legitimately answers to
decoy_group — the near-twins it is confusable with; drives the ramp
presentation_weight — how visually distinct at speed (optional)

Asset burden

Every item needs a rendering legible at speed. For pictograms that means a transparent asset authored at crossing size, not a print asset scaled down. For text items nothing beyond the string — which is why the verbal costumes of this mechanic are far cheaper to build than the visual ones.

Viable bank size

Forty per target name, and decoy groups of three or more, or the near-twin ramp has nothing to escalate into.

built as: drive-corps:recon-sweep · concept:vampire-survivors-word-stream · concept:wildlife-photography · concept:grammar-radar · presentation:whack-a-mole (concurrency > 1)

One target hidden among near-twins in a static field; no clock, accuracy is the whole score.

• wears
• spotter
• inspector
• quartermaster
• restorer
• proofreader

The loop

A scene is presented whole, one named target somewhere inside it, a dozen or more near-twins arranged as honest scenery rather than as a lineup. No clock. The player scans until sure, clicks, and is scored on whether they were right and how long it took — with the time reported afterward and never displayed during.

Consequence — what the fiction must deliver

Being wrong in front of the scene. The click lands, the scene stays up, and the real target is revealed where it always was. That is a specific and useful embarrassment, because the player sees exactly what they looked past. No fuel, no timer, no rescue.

Teaches well / badly

The complement to fast recognition: this is where discrimination gets built, because every decoy is wrong in exactly one respect. Suits any dense visual or textual field with genuine near-misses. Useless for recall — the target is named, so nothing is retrieved; the player is matching, not remembering.

Becomes a worksheet when

It becomes a worksheet when the decoys stop being near-misses. Fill a scene with unrelated items and the target pops out preattentively: two seconds, nothing trained, a spot-the-difference with one difference. The tell is search time falling below about three seconds across the board.

One unit of content

One scene: a named target, a placement, and a set of decoys drawn from that target's near-twin group.

Required fields

scene_id
target — item id
decoys — item ids, drawn mostly from the target's decoy_group
layout — positions and scales, or a generator seed
backdrop — the scene art this arrangement sits in
reveal_note — one line on what made the true target identifiable, shown after a miss

Asset burden

THIS IS THE BLOCKER, and the reason Sniper Spot was never built. Each scene needs a backdrop plus every item rendered at scene scale under consistent lighting. Three routes, cheapest first: (a) flat schematic backdrops — a briefing board, a peg wall, a contact sheet — where items are pinned and no perspective is required; (b) one photographic backdrop reused across many arrangements with items composited in; (c) bespoke illustrated scenes, which is where it stalled. Route (a) is about a day of work and should be assumed unless someone decides otherwise.

Viable bank size

Twenty scenes minimum, but scenes are cheap once a layout generator exists. The real constraint is decoy groups of three or more, without which arrangements repeat visibly.

built as: drive-corps:sniper-spot (unbuilt)

The scene freezes after a few seconds; click where attention should have gone, not what the answer was.

• wears
• apprentice under a master
• trainee analyst
• student of a detective
• spotter

The loop

A full scene — a problem, a passage, a photograph — is shown for a few seconds and then covered. The player clicks where the expert's eye went, on the blank. The scene returns with the true attention map over it: the two places that mattered, and the three that looked like they did.

Consequence — what the fiction must deliver

The overlay. Seeing your own click sitting on an irrelevant corner while the two live regions glow elsewhere is a specific and useful embarrassment, and it needs no words.

Teaches well / badly

Salience. It scores WHERE attention went rather than what the answer was, which nothing else here does, and it is the most direct expression of the superpower framing — the sense that an expert sees a different picture. Poor for anything with a single obvious focus; if there is one place to look, the mechanic has nothing to teach.

Becomes a worksheet when

It becomes a worksheet when the attention map is the answer key in disguise. If the region to click is simply where the answer lives, the player is answering the question with an extra step. The map has to mark where an expert LOOKS — including places they check and dismiss — not where the solution sits.

One unit of content

One scene with an authored attention map: the regions that matter, ranked, plus the decoys that attract a novice.

Required fields

scene_id
display — the scene as shown, and the exposure duration
regions — coordinates, each with a rank and a one-line reason it matters
decoy_regions — where a novice looks and why it is wrong
debrief — the sentence shown over the overlay

Asset burden

EXPENSIVE, and the contract is the risk. Every scene needs coordinates authored by someone who can actually say where an expert looks — this cannot be generated, and it cannot be inferred from the answer.

Viable bank size

Scenes are single-use. Thirty is a session; three hundred is the real requirement, and nobody has costed that.

One moment turns the whole thing; locate it. Not an error — a hinge.

• wears
• historian
• negotiator
• chess annotator

The loop

A whole passage or problem is shown, intact and correct. Nothing is wrong with it. The player marks the single place where its direction changes — the however, the hidden equality, the modifier that reverses the sentence — and the reveal shows the true hinge alongside the places that merely looked like one.

Consequence — what the fiction must deliver

The near-misses light up too. Seeing that you marked a place that looks pivotal but carries nothing is the lesson, and it needs no explanation.

Teaches well / badly

Structural reading. The player learns that most of a text is scaffolding and one part of it is load-bearing, which is closer to how a fast reader actually works than any comprehension question. Poor for anything without a turn — a flat descriptive passage has no hinge and the player will invent one.

Becomes a worksheet when

It becomes a worksheet when the hinge is a keyword. If 'however' is always the answer, the player learns to search for connectives, which is a real reading heuristic being taught in the most brittle possible way. Some items must turn without a signpost.

One unit of content

One intact item with a single marked hinge and the places that resemble one.

Required fields

item_id
content — the passage or problem, unmodified
pivot_location — the one place the direction changes
why_it_turns — the line shown on reveal
near_pivots — locations that look load-bearing and are not, each with why
signposted — whether the hinge is marked by a connective, so a bank can balance them

Asset burden

None. Marking is a text-range interaction.

Viable bank size

Items are single-use once found. Same economics as Where Experts Look, and the same unsolved problem.

A chain of reasoning unfolds line by line; call it clean or broken as early as you dare, then name the error.

• wears
• detective
• cross-examiner
• peer reviewer
• debate judge

The loop

A suspect narrates a line of reasoning, one line at a time, at reading speed. The player can call it clean or broken at any point; calling early is worth more and being wrong early costs more. On a broken call the narration stops and the player picks which error it was from a lineup of named culprits.

Consequence — what the fiction must deliver

The narrator carries on being wrong. Letting a broken chain run to its conclusion and watching it arrive somewhere confident is a stronger correction than a buzzer, because the player sees where not-noticing leads.

Teaches well / badly

Judging someone else's reasoning, which is a different act from producing your own and much closer to what a reader actually does. Suits anything with a taxonomy of ways to go wrong. Poor where errors are idiosyncratic — if each break is unique, the naming stage has nothing to name from.

Becomes a worksheet when

It becomes a worksheet when the break is obvious from line one. If the chain is wrong immediately, earliness stops being a wager — every round is called at the first opportunity and the mechanic degenerates into a slow multiple choice. Half the rounds must be clean, and the broken ones must be plausible until they aren't.

One unit of content

One narrated chain: an ordered run of reasoning lines, the index where it breaks, and which named error it is.

Required fields

round_id
context — the passage or problem being reasoned about
reasoning — ORDERED lines, spoken in sequence
break_idx — the index where the chain goes wrong; null for a clean round
con_id — the named error, from the taxonomy
innocent_twin — a clean round built on the same material, so clean is not detectable by vibe
answer — where the chain SHOULD have landed

Asset burden

A face and a name per culprit. The narration is text.

Viable bank size

Forty rounds, at least half clean. break_idx points into reasoning, which no schema language here can validate — that stays a script's job.

built as: peregrine:lineup

Each subject presents credentials against rules that keep changing; approve or turn away, and wear the consequence.

• wears
• checkpoint officer
• copy editor
• building inspector
• customs officer
• permit clerk
• peer reviewer

The loop

A subject arrives with a set of documents. A rulebook, consultable but costly in time, says what makes them admissible. The player approves or rejects, the queue advances, and every few subjects a new rule joins the book without any old one retiring. A shift ends on a clock or a quota. Consequences arrive after the decision, sometimes several subjects later.

Consequence — what the fiction must deliver

Delayed and attributable. The collapsed building, the retraction, the patrol that starts asking questions — a bad approval returns with the specific document attached, which is what turns a wrong answer into a case the player remembers. The delay is the design; immediate correction would collapse this into a stream.

Teaches well / badly

The only mechanic here that trains rules ACCUMULATING, which is far closer to how a real body of knowledge behaves than any single-criterion drill. Excellent for layered, interacting conditions — grammar, code compliance, eligibility. Poor for isolated facts, where the growing rulebook is overhead with nothing to interact with.

Becomes a worksheet when

It becomes a worksheet when the rules stop interacting. If every subject fails exactly one rule, the player learns to scan for one violation and stop reading — a checklist, not a judgment. The mechanic only earns its complexity when some subjects fail two rules, some fail none, and at least one rule sits in tension with another.

One unit of content

One subject: a document set, plus which rules it satisfies and which it violates.

Required fields

subject_id
presentation — the documents as the player sees them, laid out to be read rather than parsed
violations — rule ids broken; empty for a clean subject, and clean subjects must be common
satisfies — rule ids explicitly met, for subjects that look wrong and are not
consequence_text — what comes back on a wrong decision, written as an event rather than a correction
shift_min — earliest shift this can appear, gated on the rules it needs
RULE CLASS: rule_id, text as it reads in the book, introduced_shift, interacts_with
RULE MODE (declare per game): accumulate-only, or retire-and-reverse. Border/Customs accumulates — rules pile up and none retire. Dystopia's Retroactive Directive reverses: a rule can invert and re-judge decisions the player already made correctly. Reversal changes the mechanic's subject from gatekeeping others to managing your own paper trail, so it needs consequence_text written for past subjects, not just present ones.

Asset burden

The document rendering IS the mechanic — a permit that reads as a form, a proof that reads as a manuscript. This is a typography and layout problem rather than an illustration one, which makes it far cheaper than Cluttered Search and is a strong argument for building it earlier.

Viable bank size

Twelve to fifteen rules across a campaign, roughly eight subjects per shift. Subjects are cheap; the rules are the design, and they must be written to interact before any subject is authored.

built as: drive-corps:checkpoint (unbuilt)

Items stream past; flag the ones that fail inspection, and let the sound ones through.

• wears
• scanner operator
• copy editor on deadline
• inspector
• customs officer
• fact-checker

The loop

A standard is fixed — a comma splice, a contraband class, a dangling modifier. Items cross on a timer. Most of them are fine. The player flags the ones that fail and lets the rest through; a false flag costs more than a miss, because stopping a clean shipment is the expensive mistake in every fiction this wears.

Consequence — what the fiction must deliver

The thing you let through comes back. A missed fault surfacing later — the retraction, the seizure, the sentence in print — is a stronger correction than a buzzer, and it is the one consequence this mechanic shares with Stamp or Reject.

Teaches well / badly

Discrimination against a standard rather than against an exemplar — the player is not asked what this is, but whether it is sound. Suits anything with a taxonomy of faults. Poor where soundness needs context beyond the item, since nothing crossing the screen can be checked against anything else.

Becomes a worksheet when

It becomes a worksheet when half the items are flawed. A fifty-fifty stream trains a coin flip; the restraint this mechanic exists to build only develops when flagging is rare and expensive. Below about one in five, the player starts tapping everything.

One unit of content

One item carrying a verdict — sound, or failing in a named way. Clean items are content too, and they are the majority.

Required fields

id
display — the item as it crosses
verdict — clean or flawed; the bank must run at least four clean to one flawed
fault_id — which named fault, from the guide's taxonomy; null when clean
concept — the skill this scores against, so the miss log means something
plausible_clean — for clean items that resemble a fault, the reason they are fine
FAULT TAXONOMY (guide-level): fault_id, name, one-line description

Asset burden

Text items need nothing. Visual costumes need the item legible at crossing speed, same as Stream Match.

Viable bank size

A hundred and fifty items at four-to-one, so roughly thirty flawed. The expensive field is plausible_clean — a clean item that looks wrong is worth three that obviously aren't.

built as: peregrine:target-practice · concept:contraband-scanner · concept:speed-edit · presentation:whack-a-mole (concurrency > 1)

Classify against a draining budget with your own best run drawn on the track beside you.

• wears
• racer
• dispatcher
• emergency responder

The loop

An item appears with a budget ring already draining. The player names its type and its first move, and that is the whole turn — the item is never worked. A ghost marker shows the player's own best pace on the same concept, running alongside.

Consequence — what the fiction must deliver

The ghost pulls ahead or falls behind. Feedback is comparative and private; there is no opponent and no correct-answer chime, just a version of you that was faster last week.

Teaches well / badly

Recognition speed, isolated from execution deliberately. It trains the thing experts do before they start — seeing what kind of thing this is — and it is the only mechanic here that scores that in isolation. Teaches nothing about actually solving, which is the point and the limit.

Becomes a worksheet when

It becomes a worksheet when the type is inferable from surface features. If every geometry item mentions a triangle, the player learns to spot the word rather than the structure — and gets faster while learning less, which the ghost will happily reward.

One unit of content

One item to classify — never to solve.

Required fields

item_id
stem
type_options — the classification taxonomy, shared across the bank
correct_type
move_options — the opening moves, shared across the bank
correct_move
budget_seconds — the ring for this item
concept — what the ghost is measured per

Asset burden

None. Text items only.

Viable bank size

A hundred and fifty. Items are cheap because nothing needs a worked solution — which is what makes this the cheapest bank in the catalog to author.

built as: peregrine:snap-call

Name the pattern, then actually do the work, both on one clock.

• wears
• field surgeon
• mechanic
• climber calling a route

The loop

One clock covers both halves. The player names the approach, then actually executes it and submits an answer. A wrong call is survivable but expensive, because the execution that follows is the wrong execution. Hints are available and every reveal is recorded.

Consequence — what the fiction must deliver

Committing to a bad approach and feeling it cost you. The clock keeps running through the wrong method, which is the specific pain that teaches approach selection.

Teaches well / badly

The join between recognition and execution, which neither half tests alone. A player who can name the approach but cannot run it looks competent under Beat Your Ghost and fails here. Poor for anything with no execution worth doing — a one-step item makes the call redundant.

Becomes a worksheet when

It becomes a worksheet when the call is cosmetic. If any approach can solve the item, naming one is decoration and the mechanic is a timed problem set. At least one wrong approach must be genuinely slower or dead-ended.

One unit of content

One problem that can be BOTH classified and solved — which means it needs everything Beat Your Ghost needs plus a worked solution.

Required fields

item_id
stem
type_options — the same taxonomy Beat Your Ghost uses
correct_type
answer
choices (optional — free entry also works here)
solution_steps — the worked path, for the hint ladder
hints — ORDERED partial reveals drawn from solution_steps
wrong_approach_cost — what naming the wrong method actually costs on this item
one_clock_seconds
concept

Asset burden

None beyond the items.

Viable bank size

Sixty. Far more expensive per item than Beat Your Ghost because every item needs an authored worked solution and a hint ladder.

built as: peregrine:beat-the-shakedown · sat-math:shortcut-race (concept)

Evidence arrives a piece at a time; name the answer on as little of it as you dare.

• wears
• detective
• poker player
• doctor ordering tests

The loop

A case opens with almost nothing. Each reveal buys another independent clue and costs score. At any point the player names the answer; the payout is what remains. The round ends on the call, right or wrong.

Consequence — what the fiction must deliver

The unspent clues. Being right with four unopened envelopes on the table is the reward, and being wrong with them is worse than being wrong having opened everything — the game shows what you left unread.

Teaches well / badly

Sufficiency — knowing when you know enough, which is the judgment most absent from ordinary practice, where all the information arrives at once whether you needed it or not. Suits anything with converging partial evidence. Useless for single-fact recall, where there is nothing to accumulate.

Becomes a worksheet when

It becomes a worksheet when one clue is decisive. If clue three settles it every time, the mechanic teaches the player to open three and stop. Discriminating power has to vary across the set, and some cases must genuinely require most of it.

One unit of content

One case: a set of INDEPENDENT clues, each with a reveal cost, plus the answer and the candidates the clues eliminate.

Required fields

case_id
answer
candidates — every answer the case could plausibly resolve to
clues — UNORDERED and independent; each names which candidates it eliminates and its reveal cost
minimum_sufficient — the smallest clue subset that determines the answer, for scoring efficiency
red_herring_clues — consistent with the answer but eliminating nothing

Asset burden

Presentation per clue type (a photograph, a statement, a record) sells it, but text carries it.

Viable bank size

Thirty cases with five to eight clues each. The expensive field is minimum_sufficient — it has to be computed against the candidate set, not asserted.

built as: peregrine:the-make · concept:information-economy

Each item yields only to the right instrument; the wrong choice costs time rather than points.

• wears
• angler
• locksmith
• surgeon
• safecracker

The loop

An item is presented alongside a rack of instruments the player has collected. Choosing the right one resolves the item immediately and shows what it did. Choosing wrong wastes tempo, the item stays, and the rack is still there.

Consequence — what the fiction must deliver

Recoverable failure. The wrong tool costs seconds, not the item, which makes the emotional register inefficiency rather than error — and that changes who will keep playing after a bad run.

Teaches well / badly

Method-to-problem mapping, without ever asking the player to execute the method. Suits any domain with a small closed set of approaches and items that announce which one they want, quietly. Poor where the method is the hard part — this mechanic asserts that once you have chosen correctly, the work is done.

Becomes a worksheet when

It becomes a worksheet when the rack is large. Past six or seven instruments the player stops recognising and starts eliminating, and a mechanic about method selection becomes a mechanic about process of elimination.

One unit of content

One item plus the instrument that resolves it. NO worked solution — the tool is the solution.

Required fields

item_id
stem
correct_tool — an id from the guide's shared instrument rack
wrong_tool_outcomes — what each wrong instrument visibly does, and its tempo cost
why_this_tool — the line shown after a correct pick
TOOL RACK (guide-level, not per item): tool_id, name, what it does, when it is acquired

Asset burden

An icon per instrument. The rack is the only art requirement and it is small and reusable.

Viable bank size

Eighty items over a rack of five or six. Cheaper per item than Call Then Execute — no solution to author — but the rack itself is the design.

Two people hold halves that are meaningless alone and sufficient together. Neither can see the other's.

• wears
• expedition partner
• bomb technician
• handler and asset
• dispatcher and driver

The loop

The problem is cut in two and dealt out. Each side holds information the other needs and cannot show. Progress requires describing what you hold accurately enough for someone who cannot see it to act, and asking well enough to get what you are missing. The round ends when the pieces are assembled or the clock beats them.

Consequence — what the fiction must deliver

Being misunderstood. The other player acts on your description and it is wrong, and the failure is legibly yours — which is a sharper correction than any scoring rule, and needs no authoring.

Teaches well / badly

Articulation. This is the only mechanic here where the player must put knowledge into words for another person, which is a far harder test than recognising or selecting — a player who can identify a comma splice on sight discovers they cannot describe one. Poor for anything where the vocabulary is the content being taught, since the pair will invent their own shorthand within two rounds.

Becomes a worksheet when

It becomes a worksheet when one half is decorative. If side A can solve it alone and side B is reading out a manual, that is one player being assisted, not two holding halves. Both sides must be able to fail the other.

One unit of content

One SPLIT case: two halves, each insufficient alone, jointly sufficient — plus what each side may and may not see.

Required fields

case_id
half_a — what one side holds
half_b — what the other holds
answer — derivable only from both
visibility — what each side is forbidden from seeing
asymmetry_check — proof neither half alone determines the answer
shared_vocabulary — terms both sides start with, so the first minute is not spent inventing words

Asset burden

None beyond presenting each half. The cost is authoring: asymmetry_check is a real constraint and most naive splits fail it.

Viable bank size

Twenty cases. Low volume because each is played once per pair, but every one must be verified genuinely non-solvable from either side.

built as: concept:keep-talking-and-nobody-explodes · concept:the-half-map (hidden-treasure structure)

One countdown for a whole hidden payload; each correct answer buys progress, each wrong one costs time and comes back.

• wears
• radio operator
• codebreaker
• dispatcher
• night-shift technician

The loop

One countdown governs a whole hidden payload rather than a single question. Each correct answer reveals the next fragment and buys back a little time; each wrong one costs time and returns the item to the queue a few items later. The round ends when the payload completes or the clock runs out mid-sentence — which is the more common and the more motivating outcome.

Consequence — what the fiction must deliver

The payload. A wrong answer does not say wrong — it eats the seconds needed for the last three words, and the message left unfinished is a real sentence the player wanted to read. Withholding the ending is the whole of the consequence design.

Teaches well / badly

Suits recall across a large flat body of independent facts where the failure mode is forgetting rather than confusion — regulations, definitions, conversions. Poor for anything needing sustained reasoning: the clock makes a two-minute problem feel like a punishment, and the requeue delivers that punishment twice.

Becomes a worksheet when

It becomes a worksheet when the payload is filler. A procedurally generated or obviously irrelevant transmission turns the clock into a timer on a quiz, and the player learns to ignore the fiction entirely. The payload has to be worth finishing — which caps the mechanic at however many good ones someone is willing to write.

One unit of content

One question with a single unambiguous answer — and, separately, one payload worth completing.

Required fields

id
stem
choices
answer
concept — scoring key for the requeue and for cross-game miss weighting
time_value — seconds bought by a correct answer (optional, defaults by difficulty)
requeue_distance — items before it returns (optional, defaults 2–4)
PAYLOAD CLASS: payload_id, text, fragment_count, context — why this message matters to the player's role

Asset burden

None for the questions. The payload wants a rendering that sells it as a document — a teleprinter face, a smudged carbon, a redacted memo — because the payload is the reward, and a reward set in body text does not read as one.

Viable bank size

A hundred questions supports a long session, but the binding constraint is payloads: ten to twelve good ones is a game, and they are hand-written, never generated. Budget the payloads first.

built as: drive-corps:intercept

Turn a lot into a little — summarise, categorise, coin the rule that covers all of it.

• wears
• editor writing a headline
• cartographer
• teacher
• archivist
• broadcast editor

The loop

A body of material is given — a passage, a run of worked examples, a set of events — with a budget: one sentence, five words, one rule. The player produces the compression. Scoring asks what survived: is the load-bearing thing still there, and is anything false now implied?

Consequence — what the fiction must deliver

The comparison. Showing the player's line beside a strong one, with what each kept and dropped, is the whole lesson and it works even when the player did well.

Teaches well / badly

The closest thing here to what expertise actually is, because compressing correctly requires knowing what matters. Suits summary, categorisation, coining a rule. Hopeless for recognition — there is nothing to compress in a single item.

Becomes a worksheet when

It becomes a worksheet when it becomes multiple choice. Pick-the-best-summary is a recognition mechanic wearing this one's clothes, and it is the shortcut every implementation will be tempted into because it makes scoring trivial.

One unit of content

One source plus a budget, and — this is the problem — a way to score a free-text answer.

Required fields

source_id
material — what is being compressed
budget — the constraint (one sentence, five words, one rule)
must_survive — the elements a correct compression cannot drop
must_not_imply — falsehoods a lossy compression tends to introduce
reference — a strong compression, for the comparison screen
SCORING: either an authored acceptance set, or a runtime judge

Asset burden

None. The cost is entirely in must_survive / must_not_imply, which is real editorial work per item.

Viable bank size

Twenty is plenty — it is a capstone, not a stream. Which is fortunate, because each one is expensive.

Ten rounds share a principle nobody stated. Name it.

• wears
• codebreaker
• naturalist
• apprentice
• initiate
• scholar

The loop

A run of items goes by, all correctly answerable without knowing why. Every one of them shares a principle nobody has stated. At the end the player is asked what they had in common — and only then does the game confirm it, name it, and show the run again with the principle visible.

Consequence — what the fiction must deliver

The replay. Being told the principle is weak; being shown the ten items again with the pattern lit up is the payoff, because the player recognises their own experience of it. Getting it wrong costs nothing but the replay lands harder.

Teaches well / badly

Induction. Suits anything where the rule is more valuable than the instances — subject-verb agreement across ten sentences that look unrelated, a trap type worn by six different questions. Useless for anything with no generalisation behind it: a run of unrelated facts has no rule to find, and the player will invent one.

Becomes a worksheet when

It becomes a worksheet when the rule is announced first. Any tutorial text, any category label on the run, and the induction collapses into confirmation. It also fails when the run is too short: three items support several rules and the player who names the wrong one is right and told they are wrong.

One unit of content

One RUN — a set of items sharing an unstated principle, plus the principle and its acceptable phrasings.

Required fields

run_id
principle — the rule, in the words the game will accept
accepted_phrasings — the ways a player might say it correctly
items — the item ids in the run, all answerable without the rule
near_miss_rules — plausible wrong principles the run must NOT also satisfy
replay_note — what to highlight when the run is shown again

Asset burden

None beyond the housed items. The replay wants a highlight treatment, which is rendering rather than art.

Viable bank size

Eight to ten items per run, and enough runs that the player never sees one twice. near_miss_rules is the expensive field — authoring a run that supports exactly one principle is harder than it sounds.

Named characters live or wash out on your answers; the score is who is left.

• wears
• squad leader
• shift supervisor
• expedition captain
• editor with a staff

The loop

A named cast is introduced before the first question. Correct answers advance a specific person; wrong answers remove one, by name, permanently for the run. The score is the roster at the end. The round ends when the questions run out or the roster does.

Consequence — what the fiction must deliver

A person leaves. No red X, no deduction — a name greys out, does not come back, and the player is the reason. The strength and the danger are the same thing: consequence entirely decoupled from what was actually misunderstood. It must sit over a mechanic that already gives real feedback, never replace one.

Teaches well / badly

Indifferent to knowledge type — which is both the point and the risk. It attaches to any bank without caring what is in it, making it the cheapest possible test of whether the philosophy works and the easiest thing here to apply thoughtlessly. It teaches nothing on its own; it changes only why the player cares.

Becomes a worksheet when

It becomes a worksheet the instant the roster is generic: eight interchangeable names with no voice is a lives counter with extra steps, and players detect this in about two runs. It fails in the opposite direction too — attrition over a bank the player was never taught from is just punishment, and this mechanic's total indifference to knowledge type makes that easy to do by accident.

One unit of content

One roster member — plus, separately, whatever the host mechanic's content unit is. This entry never ships alone.

Required fields

character_id
name
one_line — the single detail that makes them distinguishable
voice — a line on promotion and a line on washing out
portrait (optional)
promotion_track — the ranks or states they move through

Asset burden

Portraits help enormously and are the difference between a name and a person, but a strongly written one-liner carries it alone. Do not generate the cast.

Viable bank size

Eight to ten. Fewer and a run ends too early; more and the player never learns who anyone is, which removes the only thing the mechanic does.

built as: drive-corps:the-squad (unbuilt) · drive-corps:checkpoint (threat meter, unbuilt)

Shields, crits, and a named opponent wrapped around a mechanic that already works.

• wears
• challenger
• tournament fighter
• rival's opponent
• interrogator

The loop

A named opponent stands between the player and the next rank, with a visible health bar the host mechanic's items chip away at. Shields demand a streak before damage lands; crits reward a run of clean answers; the boss's own specialism is drawn from the player's worst concept, so the fight is personalised without being announced. The round ends when one bar empties.

Consequence — what the fiction must deliver

The bar, and the taunt. A miss is the boss landing a hit and saying something about it, which converts an error into an exchange. The danger is that the taunt is the only feedback: a boss layer over a mechanic with no real diagnosis leaves the player beaten and uninformed.

Teaches well / badly

Indifferent, exactly like Roster Attrition — it inherits whatever the host teaches. What it adds is a REASON to sustain attention across a longer run than the host would otherwise support, which is worth something on a mechanic whose natural round is thirty seconds.

Becomes a worksheet when

It becomes a worksheet when the boss is arithmetic. If shields and crits are just multipliers on the same item stream, the player is doing the host mechanic with a slower scoreboard. The boss has to change what the player DOES — force a streak, punish a specific concept — or it is decoration.

One unit of content

One boss — plus, separately, whatever the host mechanic's item unit is. THIS ENTRY NEVER SHIPS ALONE.

Required fields

boss_id
name
specialism — the concept this boss draws its attacks from, or 'player's weakest'
health / shield / crit thresholds
taunts — lines on landing a hit and on taking one
portrait (optional)
HOST: names the mechanic whose items feed the fight

Asset burden

A portrait and a name carry it. Everything else is chrome over the host's content.

Viable bank size

One boss per rank tier. Fewer than four and the frame is spent in a session.

built as: peregrine:kingpin-showdown

Stop now and keep what you have, or continue and risk all of it.

• wears
• gambler
• salvage diver
• prospector
• game-show contestant
• heist crew

The loop

Successes accumulate into a pot that is visible and not yet yours. At intervals the game offers to bank it. Push instead and the next success pays more, the next failure takes everything. The round ends when the player banks, busts, or the host mechanic runs out of items.

Consequence — what the fiction must deliver

Losing a pot you could see. Busting after four correct answers is felt far more than four separate misses, and the number was on screen the whole time. That is also the risk — the sting attaches to the gamble rather than to the thing misunderstood, so it must sit over a mechanic that already tells the player what they got wrong.

Teaches well / badly

Indifferent to knowledge type — it inherits whatever the host teaches. What it adds is a self-assessment beat: to push well the player has to know whether they actually know the next thing, which is calibration arriving through the back door rather than through a wager screen.

Becomes a worksheet when

It becomes a worksheet when the ladder is linear. If pushing is worth a flat increment, the correct play is always to push until the expected value flips, the player computes it once, and the choice stops being a choice. The curve has to bend — and it has to bend somewhere the player can feel rather than calculate.

One unit of content

One stake ladder — the payout curve and where the offers land — plus, separately, whatever the host mechanic's item unit is. THIS ENTRY NEVER SHIPS ALONE.

Required fields

ladder_id
payout_curve — what each successive success is worth; must bend, not scale
offer_points — after which successes the bank offer appears (never player-initiated)
bust_rule — what a failure costs at each rung
flavour — what banking and busting are called in the fiction
HOST: names the mechanic whose successes feed the pot

Asset burden

None. The pot needs to be legible on screen at all times, which is layout rather than art.

Viable bank size

One curve per host mechanic, tuned. This is a tuning artefact, not a bank — there is no content to author at volume.

A fiction that houses several unrelated mechanics behind one goal.

• wears
• escapee
• investigator working a room
• tomb raider
• initiate

The loop

A bounded space holds three or four unrelated challenges and one goal. Solving one unlocks or reveals the next; the player chooses what to attempt and in what order within whatever the room permits. The round ends when the goal is reached or the clock, if there is one, runs out.

Consequence — what the fiction must deliver

The door. Progress is spatial and legible — you are further in, or you are not — which is a stronger signal than a score because the player can see it without reading it.

Teaches well / badly

Its real contribution is BREADTH — it is the only structure here that can put four different kinds of knowing in front of a player inside one sitting without the transitions feeling like a menu. A single mechanic cannot cover proportions and inscriptions and ciphers; a room can, and the fiction explains why they sit together.

Becomes a worksheet when

It becomes a worksheet when the room is a menu with scenery. If the four challenges are independent, unordered, and equally available, the container has added a backdrop to a level select. The room only earns itself when the order is constrained and something found in one challenge is needed in another.

One unit of content

NO ITEM UNIT OF ITS OWN — and that is the finding. A container's content is a room: which mechanics it houses, in what order, and what unlocks what. Every actual item comes from the housed mechanics.

Required fields

room_id
goal — what reaching the end means in the fiction
slots — the housed mechanics, in dependency order
gating — what each slot unlocks, and any cross-references between slots
scene — the space the whole thing sits in

Asset burden

A room needs a place. This is the illustrated tier — the container's whole value is that the space is legible, which a flat backdrop does not deliver.

Viable bank size

Four to six rooms. Content scales by room, not by item, which is the economics that make it attractive.