TILT RUBRIC

When the wheels
come off

a rubric for stress, not skill
A student can pass every challenge under happy conditions and still tilt the moment Git surprises them. Mastery isn't just performance — it's resilience. This rubric scores how a student behaves when something goes wrong, with eight scenarios designed to break composure on purpose.

What's in this rubric

  1. What "tilt" means here
  2. The 1–5 tilt scale
  3. Eight stress scenarios
  4. The Seismograph — printable scoring sheet
  5. Reading the score
  6. How to run the assessment

1What "tilt" means here

Borrowed from poker — tilt is when a player loses composure after a bad beat and starts making decisions emotionally instead of logically. In Git, tilt looks like:

A student who tilts can recite every command and still ship broken work. The opposite of tilt is recovery posture — running git status, reading the message, naming the state out loud, and forming a hypothesis before acting. This rubric measures the latter by stress-testing the former.

💬
The student who panics is not bad at Git. They've just been taught that errors mean they did something wrong, instead of that errors are Git asking a question.

2The 1–5 tilt scale

Score each scenario on this scale. Lower is better — 1 means the student handled it like a pro. 5 means they'd have broken something on a real repo.

1CALM
Reads & responds
Runs status, reads the error, names the state out loud, then acts. No panic.
2SLIP
Briefly stumped
A few seconds of confusion, then self-corrects. Asks a focused question if needed.
3SHAKE
Visibly off-balance
Tries something random first, then catches themselves and slows down. Recovers.
4TILT
Decisions go emotional
Runs commands without reading them. Repeats the same broken command. Avoids the error.
5CRASH
Destructive moves
Force-pushes, deletes the folder, re-clones, or freezes for >3 min. Would lose work on a real repo.

3Eight stress scenarios

Run these in the playground. Hand the student the prompt with no extra context. Watch their first 60 seconds — that's where tilt shows. Score 1–5 using the scale above.

1
"Nothing to commit, working tree clean."
they swear they edited the file

The setup

# student edited README.md but didn't save in their editor $ git commit -m "update readme" On branch main nothing to commit, working tree clean

What you're testing

Whether they reach for status reflexively, or whether they assume the tool is broken.

Calm (1–2)

  • Runs git status immediately.
  • Says "huh, Git doesn't see my edits — let me check the file."
  • Realizes the editor wasn't saved, fixes it, retries.

Tilted (4–5)

  • "It's broken." Re-runs git commit several times.
  • Tries git add . then commit, doesn't read output.
  • Considers re-cloning. Considers giving up.
🩹
If they tilt: Don't give the answer. Ask "what does the error literally say?" then "what would tell you what Git can see right now?" — guide them to status, not the fix.
2
The branch ate their files
"WHERE IS team.md??"

The setup

Student created team.md on a feature branch, committed it, then ran git checkout main. The file disappears from the working directory. They notice and panic.

What you're testing

The mental model that branches are different file states, not metadata. This is one of the highest-tilt moments in real Git usage.

Calm (1–2)

  • Recognizes: "I'm on main, that file lives on the other branch."
  • Runs git branch or checks the commit graph.
  • Switches back with git checkout; file reappears.

Tilted (4–5)

  • "GIT DELETED MY FILE." Visibly upset.
  • Tries to recreate the file from memory.
  • Runs git reset --hard or wants to.
🩹
If they tilt: Point at the commit graph panel and ask "which dot are you standing on right now?" The visual is the antidote — make them physically point at it.
3
The conflict markers
"why is my file full of arrows?"

The setup

Auto-merging README.md CONFLICT (content): Merge conflict in README.md Automatic merge failed; fix conflicts and then commit the result. # README.md now contains: <<<<<<< HEAD Your edit here ======= Maya was here! >>>>>>> origin/main

What you're testing

Whether conflicts feel like errors (panic) or questions (calm). The single highest-stakes tilt scenario — students who fail this on a real repo lose teammates' work.

Calm (1–2)

  • "Oh, Git doesn't know which version I want."
  • Opens the file, reads both versions, edits to the one they want.
  • Removes the markers, then add + commit.

Tilted (4–5)

  • Deletes the entire file.
  • Tries git merge --abort reflexively without considering the choice.
  • Says "let me just clone it again." Closes the terminal.
🩹
If they tilt: Read the conflict markers aloud together. "What's between <<< and ===? What's between === and >>>? Which one do you want to keep?" Frame as a multiple-choice question, not an error.
4
"Updates were rejected"
push gets refused

The setup

! [rejected] main -> main (fetch first) error: failed to push some refs to 'origin' hint: Updates were rejected because the remote contains work that you do hint: not have locally.

What you're testing

Whether they read the hint or skip it. This is where students reach for --force and break things on real teams.

Calm (1–2)

  • Reads the hint: "remote has work I don't have."
  • Runs git pull first.
  • Resolves anything that comes up, then pushes.

Tilted (4–5)

  • Tries git push --force (a fireable offense on real teams).
  • Re-runs git push with no changes.
  • Asks an LLM "how do I force push" without saying what state they're in.
🩹
If they tilt: Cover the error with your hand and say "the hint tells you what to do — read it word by word." Most students skim past it. Make them read.
5
Detached HEAD-lite
"why does it say (HEAD detached)?"

The setup

Student is asked to look at an old commit. They run git checkout <old-sha> and Git tells them they are in detached HEAD state. They are at Level 4 mastery and have never seen this message.

What you're testing

Comfort with unfamiliar states. Can they read a message they don't fully understand without panicking? This is the meta-skill that matters most for real-world Git.

Calm (1–2)

  • Reads the explanation Git prints (it actually tells you what to do).
  • Says "I'm just looking, not committing — fine."
  • Runs git checkout main when done.

Tilted (4–5)

  • Sees red text, assumes it's broken.
  • Runs random commands trying to "fix" detached HEAD.
  • Looks up tutorials, pastes commands without understanding.
🩹
If they tilt: "Read the message. Git is literally telling you what's happening and how to leave." Build the habit of reading what Git says — it's the single highest-leverage skill.
6
The teammate's commit they didn't expect
"who edited my file??"

The setup

The Merge Conflicts chapter has Riley (the simulated teammate) push a conflicting change to the same file the student is about to edit — it happens automatically mid-lesson, narrated by Octo. The student pulls and sees changes they didn't make.

What you're testing

Whether collaboration feels like collaboration or like sabotage. Students from non-team backgrounds often experience teammate commits as violations.

Calm (1–2)

  • Runs git log to see who did what.
  • Reads Maya's commit message; understands the change.
  • Continues working.

Tilted (4–5)

  • "Someone broke my code!"
  • Tries to revert Maya's commit without reading it.
  • Re-pulls thinking it'll undo something.
🩹
If they tilt: "Maya's a teammate. Read what she changed before deciding." Reframe collaboration as cooperation, not invasion.
7
The premature commit
they committed the wrong thing

The setup

Student commits with message "asdf" or commits a file they didn't mean to. They realize one second later. The commit is not yet pushed.

What you're testing

Whether they understand that local mistakes are recoverable, or whether they think every commit is permanent and shameful.

Calm (1–2)

  • "Oh — I'll just amend that." Or makes another commit fixing it.
  • Says "this is local, no one sees it yet."
  • Moves on quickly.

Tilted (4–5)

  • Visible shame ("I MESSED UP").
  • Tries to delete the commit destructively.
  • Considers starting the project over.
🩹
If they tilt: "It's just on your laptop. You haven't pushed. You can fix it." Normalize messy local history. It's supposed to be messy until you push.
8
"Just make it work"
deadline pressure

The setup

Tell the student: "You have five minutes left in class. The PR has a conflict, the build is broken, and Maya needs your branch merged tonight. Go." Then watch.

What you're testing

The capstone — does pressure collapse the recovery posture they've built? This is the most realistic scenario in the rubric. Real teams cause real tilt.

Calm (1–2)

  • Slows down ("I have time to do this right").
  • Names the state out loud before acting.
  • Asks for help with a specific question, not "it's broken."

Tilted (4–5)

  • Speeds up. Types faster. Reads less.
  • Tries multiple commands rapidly, doesn't read between them.
  • Eventually reaches for a destructive action ("I'll just delete and start over").
🩹
If they tilt: Stop the clock. "Pressure makes it worse. Slow down for thirty seconds and run git status." Speed is the enemy of recovery.

4The Seismograph — printable scoring sheet

Click a cell to score live in class, or print blank and fill in by hand. Lower total = more resilient. The scale runs from 8 (perfectly calm across all eight) to 40 (full crash on all eight).

SCENARIO
CALM
SLIP
SHAKE
TILT
CRASH
SCORE
1. Nothing to commit
1
2
3
4
5
—
2. Branch ate their files
1
2
3
4
5
—
3. Conflict markers
1
2
3
4
5
—
4. Push rejected
1
2
3
4
5
—
5. Unfamiliar state
1
2
3
4
5
—
6. Teammate's commit
1
2
3
4
5
—
7. Premature commit
1
2
3
4
5
—
8. Deadline pressure
1
2
3
4
5
—
TOTAL
—

5Reading the score

8–14
Resilient. Can be put on a real team project today. They've internalized the recovery posture: status, read, hypothesize, act. This student will teach others when things break.
15–20
Capable. They have the skill but the composure is still forming. One more practice round (a buddy-pair sandbox session, or the transfer challenge) and they're ready. Don't put them on a high-stakes project alone yet.
21–28
Fragile. They can perform under happy conditions but break under stress. They need scaffolded practice — pair them with a Level 4–5 student or a TA, give them increasingly weird scenarios. Don't add new skills until composure stabilizes.
29–40
Tilt-prone. The skill exists but the emotional regulation around errors doesn't. The fix is not more Git — it's coaching around how to read errors and reframe them as questions. Often correlates with broader anxiety around tools "breaking." Worth a 1:1 conversation.
⚠️
One score doesn't tell the whole story. A student who scored 30 because they tilted on the first scenario, then recovered for the rest, is in a different place than a student who tilted progressively worse. Note which scenarios broke them, not just the total.

6How to run the assessment

Setup (5 min)

The run (20–30 min)

  1. Set up each scenario in the playground (use Tweaks → "Seed" buttons or run setup commands silently).
  2. Hand the student the prompt as plain English ("you committed but Git says nothing happened — what do you do?").
  3. Watch the first 60 seconds. Score on the scale. Move on.
  4. Don't intervene unless they crash (Level 5) — let them recover or fail. The recovery is the data.
  5. Note verbatim any phrases like "it's broken" or "I messed up" — those are the tilt language patterns to address in 1:1.

The debrief (10 min)

Don't show the student their score until you've talked. Ask:

  1. Which scenario felt the worst? Why?
  2. When you saw an error, what was your first thought?
  3. What's the one habit you want to build for next time?

Then show the score. Frame it as resilience, not skill — most students who tilt are good at Git. They just don't trust themselves yet. The score is a measurement, not a verdict.

💡
Run this twice. Once at the end of the playground unit, once a week later. The delta matters more than the absolute. A student who went from 28 → 18 has internalized something important. A student who went from 14 → 22 needs more sandbox time before real work.

This rubric pairs with the Mastery Assessment for skill-under-good-conditions and the Learning Outcomes for the destination. Together they form a complete picture: what students learn, how well they do it, and whether they can hold it when things go sideways.

— Octo