MASTERY ASSESSMENT

How students
show they get it

a five-level rubric, four challenges, and a self-check
Mastery isn't memorizing commands — it's having the model in your head when something goes sideways. This guide gives you observable behaviors at five levels, four hands-on challenges of increasing difficulty, a grading rubric, and a self-assessment students can use without a teacher present.

What's in this guide

  1. What "mastery" means here
  2. The five mastery levels
  3. Four performance challenges
  4. Grading rubric (printable)
  5. Self-assessment checklist
  6. Oral mastery questions
  7. The real-world transfer test
  8. Tilt rubric — recognizing fragility under pressure

1What "mastery" means here

Don't measure mastery by command recall. Students forget syntax in 48 hours. Measure mastery by these three things:

  1. They can predict. Before running a command, they can tell you what will change on screen — which colors, which panels, which graph nodes.
  2. They can recover. When something looks wrong, they don't panic. They run git status, read the message, and form a hypothesis.
  3. They can translate. They can explain in plain English what's happening, and map between the playground, the real terminal, and the GitHub web UI.
💬
A student who can recite "git add then git commit" but freezes when the commit fails has not mastered Git. A student who shrugs, types git status, sees "nothing to commit", and goes "oh, I forgot to add" — that student has it.

2The five mastery levels

Use these to place a student. Most undergrads after one 50-minute class will land at Level 2 or 3. Levels 4–5 are reachable with a follow-up assignment or a second class period.

1
Novice · "I've seen it"

Recognizes the screen

  • Can point to working directory, staging, commits, and remote when asked.
  • Can type a command they've been shown moments ago.
  • Doesn't yet know why there are three local areas.
Signal: needs the hint button to do anything.
2
Emerging · "I can follow along"

Executes a known sequence

  • Can run init → add → commit → push without prompting.
  • Can name what each step does in one sentence.
  • Can read git status output and say which files are which color.
Signal: hint button off, lesson chapters complete.
3
Proficient · "I can predict"

Forms hypotheses before acting

  • Before running a command, can say what will change on screen.
  • When something unexpected happens, runs git status first.
  • Understands that branches are different files-on-disk states, not metadata.
  • Can open a PR and explain why a team would prefer it over direct merge.
Signal: passes Challenge 1 + 2 unaided.
4
Mastery · "I can recover"

Handles conflicts and divergence

  • Resolves a merge conflict by editing the file, not by panicking.
  • Can describe what's happening when the local and remote diverge.
  • Knows when to use pull, push, merge, checkout — and which order.
  • Recognizes that gh pr create in the playground IS the real GitHub CLI command — not a simulator fake. Can also explain the github.com web-UI equivalent.
Signal: passes Challenge 3 + 4 unaided.
5
Expert · "I can teach"

Explains the model to a peer

  • Can teach the three areas to a struggling classmate using the playground.
  • Can construct a non-obvious scenario (e.g. cause a specific conflict on purpose).
  • Has applied the same skills outside the simulator on a real GitHub repo.
  • Knows the limits of the simulator — what's faked vs. real.
Signal: completes the real-world transfer test (§7).

3Four performance challenges

These are scenarios. Drop a student into the playground, hand them the prompt, and watch. Each challenge maps to a mastery level — passing means doing it without hints in roughly the time given.

1
From empty folder to GitHub
⏱ 5 min Level 2 → 3 basics
Reset the playground. You're starting fresh. Build a tiny project and get it onto GitHub. The teacher will not give hints.
Goal: end with two commits visible on the remote, on branch main.

Pass criteria

  • Repo is initialized.
  • At least two distinct files exist and are committed.
  • A remote is added.
  • Both commits are visible on the right-hand (remote) graph.
  • Student can explain in one sentence why add exists separately from commit.
2
Branch, merge, and explain
⏱ 7 min Level 3 branching
Your friend wants you to add a "contact" page without breaking main. Do it the right way.
Goal: build the feature on a branch, then merge it back to main cleanly.

Pass criteria

  • A new branch is created with a descriptive name.
  • At least one commit is made on that branch.
  • Student switches back to main and can answer: "Where did your file go?"
  • Branch is merged back; the commit graph shows both lanes joining.
  • Student can identify the merge commit on the graph.
3
The Pull Request workflow
⏱ 8 min Level 3 → 4 collaboration
Pretend you're contributing to a real team. No direct merges allowed. Use a PR.
Goal: make a change via a feature branch, push it, open a PR, merge the PR, and pull the result back.

Pass criteria

  • Feature branch was pushed to remote before the PR was opened.
  • PR is visible in the right column with status "open" then "merged".
  • After merging, student runs git pull and can articulate why.
  • Student can name what gh pr create does on github.com (it's the same as clicking the 'New Pull Request' button).
4
Cause a conflict on purpose, then fix it
⏱ 10 min Level 4 → 5 conflicts
You and Riley both want to edit README.md differently. Make Git get confused. Then unconfuse it.
Goal: trigger a real merge conflict using collab, then resolve it and end with a clean tree.

Pass criteria

  • Student turns on the collaborator and makes Riley edit the same file the student is editing.
  • A conflict is actually triggered (file shows <<< HEAD markers).
  • Student resolves the conflict by editing the file (not by deleting it).
  • Student can explain: "Git can't pick — I have to."
  • Final commit is clean; git status reports clean tree.

4Grading rubric

For when you need a number. Score each row 1–4. A score of 12+ across the four core rows indicates mastery; 16 is expert.

Skill 1 — Novice 2 — Emerging 3 — Proficient 4 — Mastery
The three areas Confuses staging with commits. Names them when prompted. Predicts which area a file lands in. Explains why three (not two) and gives a real-life analogy.
Local vs remote Thinks GitHub is Git. Knows they're different. Predicts what push and pull change on each side. Reasons about divergence — what happens when both sides have new commits.
Branching & merging Avoids branches. Creates a branch with help. Branches, commits, switches, merges without help. Chooses when to branch vs. work on main; explains tradeoffs.
Conflict handling Panics; deletes files. Recognizes the markers. Resolves a conflict by editing the file. Causes a conflict on purpose to demonstrate; explains why git punted.
Reading git status Doesn't run it. Runs it but doesn't act on it. Uses it to decide the next command. Uses it as the first response to anything unexpected.
Mental model translation Only knows the playground. Can map playground → real terminal commands. Can map playground → terminal → github.com web UI. Knows what the simulator fakes; fills in the missing pieces verbally.
📊
Scoring guide. 6–11: still learning. 12–17: mastery for a 50-minute class — they're ready for a real repo. 18+: ready to mentor a peer.

5Self-assessment checklist

Hand this to students at the end of class or as homework. They check what they can do without looking.

Can you do this without help?

Level 2 — Emerging
Level 3 — Proficient
Level 4 — Mastery
Level 5 — Expert

6Oral mastery questions

Use these in a one-on-one (or in a circle) when you want to verify understanding, not recall. The right answer matters less than the reasoning.

Easy (Level 2–3)

  1. "Why does Git make you do add and commit as two separate steps? Why not one?"
  2. "What's the difference between something on your laptop and something on GitHub?"
  3. "If you switch to a branch and a file disappears, where did it go?"

Medium (Level 3–4)

  1. "You ran git commit but it said 'nothing to commit'. What did you forget?"
  2. "Your friend pushed a change and you also pushed a change. What does GitHub do?"
  3. "What's a Pull Request actually for? Why not just merge?"

Hard (Level 4–5)

  1. "You see <<<<<<< HEAD in your file. What does that mean and what do you do?"
  2. "Explain to me, like I'm a friend who's never coded, what a Git commit actually is."
  3. "What in this playground is faked? What would be different on a real machine?"
🐙
Listen for the model, not the words. A student who answers question 8 with "it's like a save point in a video game where you can come back to it later" has a better grasp than one who recites "a commit is a snapshot of your tracked files at a point in time."

7The real-world transfer test

The ultimate mastery proof. The simulator is training wheels. This is the bike.

★
The transfer challenge
⏱ ~30 min, outside class Level 5
Make a real GitHub account. Create a real repository. Make at least three commits. Open a real Pull Request — even just merging your own branch into main. Take screenshots at each step. Explain what's the same and what's different from the playground.

Pass criteria

  • Real public GitHub repo URL submitted.
  • At least three commits in the history with meaningful messages.
  • At least one Pull Request, opened and merged on github.com.
  • One paragraph from the student naming three differences between the playground and the real thing.
  • One paragraph naming three things that felt familiar because of the playground.

If a student completes the transfer challenge, they have demonstrated mastery. They will not forget Git. They have crossed the bridge.

8Tilt rubric — recognizing fragility under pressure

A student can pass every challenge above and still tilt — fall apart the moment something unexpected happens on a real project. Mastery isn't just performance under happy conditions; it's resilience when Git surprises them. The Tilt Rubric is a separate document for this — eight stress scenarios with observable behaviors that distinguish a tilted student from a recovering one.

Use it when:

The rubric pairs with the Learning Outcomes document — outcomes describe the destination, the tilt rubric describes whether they can stay there.

— Octo