Creating Rubrics and Grading to Them

A rubric does two jobs. Before grading, it says what good work looks like, so students know what to aim for and graders know what to look for. During grading, it turns a series of judgment calls into the same decision made the same way for every student, whichever TA they get. A weak rubric does neither: "good code style, 5 points" leaves every grader to invent their own standard. This page covers choosing a rubric type, writing criteria two graders would apply the same way, testing the rubric before you grade, applying it fairly, and three example rubrics for code, proofs and written answers. Your instructor's grading scheme comes first; where this page and your course differ, follow your course and ask.

Defaults that work. If you only take four things from this page:

Write criteria you can see in the work, not value words. "Tests cover an empty input and a boundary," not "good testing."
Decide partial credit before you grade, for the mistakes you expect.
Try the rubric on a dozen real submissions and calibrate with the other graders before grading for real.
Grade to the rubric, not to your own solution. When a correct answer doesn't fit, add a rubric item and apply it to everyone.

Choose the kind of rubric

Type	How it works	Good for
Analytic	Scores each criterion separately (correctness, design, explanation), then adds them	Most CS assignments; detailed feedback; several graders
Holistic	One overall judgment against level descriptions	Short answers, quick formative checks
Checklist	Yes or no on each item	Requirements that are present or absent (files submitted, tests included)
Single-point	One column of target expectations, with room to note where work fell short or went beyond	Drafts and written work where you want comments more than points

Two more choices. Points or levels: a level-based rubric describes what each level of quality looks like and maps it to points; a pure count ("three or more tests") is easier to apply but says less about quality. Adding or deducting: in Gradescope you can start at zero and add points for what is there, or start at full marks and deduct for mistakes. Adding tends to keep partial credit consistent, because every point a student earns is tied to something specific in their work.

Build it step by step

Start from the learning goals and the model solution. What should the work show that the student can do?
List what you can see in the work that shows each goal.
Pick the rubric type and, for levels, how many. Three or four levels per criterion is usually plenty.
Write a descriptor for each level, so the difference between levels is clear.
Decide partial credit now for the mistakes you expect, and how much each costs.
Try it on about a dozen real submissions. Add items for the common mistakes you find. Keep "attempted but incorrect" separate from "no attempt."
Get feedback from the instructor and the other graders.
Revise, and regrade anything already graded with the old version.

Write criteria two graders would apply the same way

Rule	Weak	Better
Say what you can see	Good code style	Names say what they hold; no function over about 40 lines; no copied blocks
Describe quality, not only a count	Uses 3 or more test cases	Tests cover the normal case, an empty input and a boundary value
One idea per criterion	Correct and well explained	Two criteria: Correctness, and Explanation
Make the levels clearly different	Mostly correct / somewhat correct	Correct on all inputs / fails only edge cases / fails typical inputs
Name the mistake and its cost	Minor error, −1	Off-by-one in a loop bound, −1, once per problem
Avoid vague praise words	Insightful analysis	Explains why the result happens, citing a specific measurement
Let correct alternatives earn credit	Uses a hash map	Lookup runs in expected O(1) or O(log n) time

Test it before you grade

Even a good rubric reads differently to different people until they have used it together. In studies of rubric use, graders agree far more often on "within one level" than on the exact level, and several graders together are much more reliable than one. So calibrate:

Everyone grades the same five to ten submissions on their own. Pick a mix: strong, weak and odd.
Compare item by item, and talk through every disagreement of more than one level.
Rewrite the descriptors that caused disagreement, and attach an anchor example: "this is what a 3 looks like."
Grade a second shared set and check that you agree more.
Midway through grading, swap a few submissions and spot-check each other.

Keep every rubric change in one place, with the date, and apply it to the work already graded.

Apply it fairly

Grade to the rubric, not to your solution

Score what the work shows against the descriptors, not how close it is to the answer you would have written. When an answer is correct but unexpected, don't take points for being different. Tell the lead TA or the instructor, add a rubric item, and apply it to everyone.

Watch for the usual biases

Bias	What happens	Fix
Halo	A good earlier impression of a student lifts their next score	Grade anonymously when you can
Name or identity	Information about the student, not the work, shifts the grade	Hide names; Gradescope supports anonymous grading
Order and drift	Your standard moves as you grade	Grade one question at a time; regrade the first few at the end
Contrast	A paper looks better or worse next to the one before it	Compare to the anchor examples, not to the last paper
Leniency or severity	One grader is consistently higher or lower	Compare graders' averages per question during calibration
Fatigue	Late papers are graded less carefully	Grade in short blocks

The bias is real: a review of experiments on grading found that information about a student unrelated to the work shifted subjective grades by a noticeable amount, at every level from primary school to university.

Designing a rubric for grading time

Every decision in a rubric costs grading time, multiplied by every submission. So spend decisions only where judgment matters. Most of what makes a rubric faster also makes it more consistent, because graders disagree most on fine-grained calls.

Start from a time budget. Hours available divided by submissions gives minutes per submission. For example, 8 hours for 120 submissions is 4 minutes each. Time yourself grading 10 submissions with the draft rubric, and simplify until it fits.
Fewer, coarser criteria. Three or four criteria with three levels (full, partial, none) beat eight criteria with five levels. Fewer choices are faster and more consistent.
Make objective parts yes or no. "Handles the empty input" is a checkbox. Save judgment for the one or two criteria the assignment is really about.
Leave mechanical checks to the autograder. People grade what it can't check: design, explanation, proofs.
Set up the rubric for the tool. In Gradescope, order items by how often you'll use them (the first ones get the number keys), make the levels of each criterion a mutually exclusive group so each criterion is one keystroke, and write the feedback into the items so comments come free.
Cap each mistake. "Off-by-one, −1, once per problem" means you don't hunt for every repeat.
Design the assignment to be gradable, with your instructor: fixed answer areas or a template, one problem per page, the result first and then the justification, word limits, and fixed answer formats so identical answers can be grouped and graded once.
Policy choices, for your instructor to make: grade a few problems in detail and the rest for completion; specifications grading (pass or not yet); or check the final answer first and read the work only when it is wrong or partial.
Know the trade-off. Speed costs feedback. Keep one criterion with real written feedback where it matters most for learning, and say in the rubric that the rest is deliberately brief.

Prompt 6 on Using Generative AI to Draft a Rubric can do a first pass at simplifying a rubric to fit a time budget.

Three example rubrics

These are made-up examples to adapt, not rubrics from a particular course.

A. A code assignment (20 points, adding points)

Criterion	Levels
Correctness (8)	Passes all hidden tests (8) · fails only edge cases such as empty input or a boundary (5) · fails typical cases (2) · does not run (0)
Design (5)	Each function has one job, no repeated logic (5) · one oversized function or one repeated block (3) · logic repeated across the file (1)
Readability (4)	Names say what they hold, and comments explain the non-obvious parts (4) · some unclear names (2) · hard to follow (0)
Tests (3)	Normal case, empty input and a boundary (3) · normal case only (1) · none (0)

B. A proof (10 points)

Criterion	Levels
Setup (2)	States what is assumed and what will be shown (2) · one of the two missing (1) · neither (0)
Logic (5)	Every step follows from a definition or an earlier step (5) · one gap that can be fixed (3) · assumes the conclusion, or a key step is wrong (0 to 1)
Variables (1)	Each variable is introduced before use, with its range
Definitions (1)	Uses the definitions, not only restates them
Writing (1)	Full sentences; no quantifier symbols standing in for prose

C. A short written explanation (single-point)

Needs work	Target	Beyond
	States the claim in the first sentence
	Gives the correct reason it happens
	Uses one concrete example
	Under 150 words

The grader writes a short note in "Needs work" or "Beyond" next to each target.

Share it with students

Give students the rubric, or a student version of it, with the assignment. It shows what to aim for, connects the grade to the quality of the work, and lets students check their own work before they submit. Reviews of rubric research find that this kind of use can improve both performance and how well students judge their own work, especially when students actually use the rubric rather than only receive it. If some details must stay hidden (for example the hidden test cases), say what kinds of cases they cover.