Rubrics

Rubrics

Concrete grading scales for assessing student work in Geometry Playground. For the philosophy behind these rubrics, read Assessment Strategies first.

How to use this page

This page has two rubrics:

1. The master rubric. A 4-point scale across four criteria. Use it for any creative or open-ended exercise. This is the rubric you'll use most often.
2. Per-chapter criteria. Short notes on what to emphasise in each chapter. Use these to adjust the master rubric's weighting depending on what the chapter is actually teaching.

There is no auto-graded exercise bank and no answer key. The entire assessment philosophy in Geometry Playground is that the teacher's judgement, guided by a clear rubric, is more valuable than a machine-graded mark.

The master rubric

Four criteria, each scored on a 4-point scale. Total out of 16. Convert to a percentage or a letter grade using your school's scheme.

Criterion	1: Beginning	2: Developing	3: Proficient	4: Exemplary
Decomposition	One monolithic block of code. No functions or variables used to organise the work. Copy-paste throughout.	Some attempt at structure. A variable or two, maybe one function. Most of the work is still in the main routine.	Clear decomposition into functions or variables. Most repeated work is abstracted. Names are mostly meaningful.	Elegant decomposition. Small, well-named functions. Main routine is short and readable. Structure makes the code easier to understand, not harder.
Correctness	Code does not run, or runs but produces output unrelated to the exercise.	Code runs. Partial output, visible bugs, misses the main point of the exercise.	Code runs. Output matches the exercise spec. Uses the constructs the chapter is teaching.	Code runs. Output matches the spec. Handles edge cases. Demonstrates understanding beyond what the exercise strictly asked for.
Code quality	Unreadable. Poor names (x, a, b1). Inconsistent indentation. Dead code and commented-out fragments.	Partially readable. Some good names, some bad. Minor layout issues. One or two leftover fragments.	Readable by another student. Meaningful names throughout. Clean layout. No dead code.	Polished. Names are so clear that comments are unnecessary. Structure follows the logic of the problem. A student reading this code learns from it.
Creativity and ownership	Minimal engagement with the exercise. Did the bare minimum or copied a neighbour without modification.	Completed the exercise. Made one small decision of their own (a colour choice, a variation).	Completed the exercise. Added thoughtful variations, iterations, or personal touches. Evidence of experimentation (extra pages, comments).	Went well beyond the exercise. Added original elements. Took a creative risk. The work is clearly theirs, not a template.

Scoring notes:

• A score of 2 or 3 on every criterion is normal and expected for most students. The 4-point scale is not designed so that everyone scores 4. Reserve the top of the scale for genuinely exceptional work.
• Correctness is not the only thing that matters. A student who produces a working but unreadable mess should not score above 2 on code quality. A student who produces beautiful unfinished code should not score above 2 on correctness. Balance matters.
• Creativity is a ceiling, not a floor. Students who complete the exercise exactly as specified should score 3 on creativity, not 1. Low scores on creativity are reserved for disengagement, not for students who simply followed the spec. See Assessment Strategies.

Converting to a grade

Total out of 16. Suggested conversions:

Total	Percentage	Descriptor
15 to 16	90 to 100%	Outstanding
13 to 14	80 to 89%	High
11 to 12	70 to 79%	Sound
9 to 10	60 to 69%	Developing
7 to 8	50 to 59%	Basic
Below 7	Below 50%	Needs significant support

Adjust to your school's scheme. The absolute numbers matter less than consistency between students.

Per-chapter criteria

Each chapter teaches specific skills. When you mark a piece of work from a given chapter, weight the master rubric according to what that chapter is actually about.

Chapter I: Coordinate Geometry with Sequences

What to weight: correctness and creativity. Decomposition and code quality don't do much work here because the exercises are short and mostly sequential.

What proficient looks like: a student walks the pen through a polygon with the correct turn angles and correct side lengths, without using variables or loops (which come later).

What exemplary looks like: a student invents their own shape, figures out the required turn angles from the exterior angle rule, and draws something creative.

Red flags:

• Hard-coded magic numbers that don't correspond to actual geometric properties.
• Shapes that don't close. (The final position should return to the starting position.)
• Copy-pasting the same block six times instead of... well, except they don't have loops yet. This is actually fine in Chapter I.

Chapter II: Shape Properties with Variables

What to weight: decomposition (variables used appropriately) and correctness (geometric properties applied correctly).

What proficient looks like: a student uses variables to parameterise shapes, so changing one number at the top changes the whole drawing.

What exemplary looks like: a student uses multiple variables that relate to each other (width, height, diagonal) and computes the relationships correctly.

Red flags:

• Variables that are used once and never again. (Not wrong, but a missed opportunity.)
• Hard-coded numbers inside a block that should be using a variable.
• Not using the parallel-line angle properties in the Letter Z exercise.

Chapter III: Polygon Patterns with Loops

What to weight: correctness (loop used correctly) and code quality (readable loop body).

What proficient looks like: a student replaces a repeated block of code with a for loop that does the same thing.

What exemplary looks like: a student uses the loop variable inside the body to vary the shape (increasing size, rotating colour, etc.), demonstrating they understand that the index is a value they can use.

Red flags:

• A loop wrapped around a block that doesn't need repetition.
• The off-by-one error in star polygon exercises ({5/2} star drawn as a pentagon).
• Not using the greatest common divisor rule when asked about star polygons.

Chapter IV: Sorting Shapes with Conditionals

What to weight: correctness (conditionals in the right order) and decomposition (compound conditions used sensibly).

What proficient looks like: a student writes an if / else if / else chain that correctly classifies an input, with the most specific case first.

What exemplary looks like: a student uses De Morgan's laws or a well-structured compound condition to simplify a classifier that would otherwise be a long chain.

Red flags:

• The most common bug: checking "is it a parallelogram" before "is it a square" in the quadrilateral classifier. See Chapter IV.
• Using separate if statements when else if is required.
• Not understanding the difference between == and =.

Chapter V: Similarity with Functions

What to weight: decomposition (functions used sensibly) and creativity (flag variations or original flags).

What proficient looks like: a student writes a function with parameters and calls it multiple times with different arguments.

What exemplary looks like: a student composes multiple small functions into a larger one (for example, using flag component functions to build a Union Jack).

Red flags:

• Functions that take no parameters but are called with different needs. (Usually a sign the student hasn't grasped what parameters are for.)
• Using global variables instead of parameters.
• Missing argument labels in function calls.

Chapter VI: Composite Figures in Action

What to weight: all four criteria equally. This is the capstone and everything matters.

What proficient looks like: a student builds a composite scene with at least four functions and a short main routine. Z-order is handled correctly.

What exemplary looks like: a student produces a neighbourhood scene with six or more functions, uses the accumulator pattern for repeated elements like fence posts, and the code is so readable that you can predict the picture from the main routine alone.

Red flags:

• One enormous main routine with no helper functions.
• Copy-pasted house-drawing code repeated three times instead of called as a function.
• Wrong z-order (wheels drawn before the car body, chimney under the roof).
• A picture that matches the spec but code that doesn't use the constructs from Chapter V.

A sample marking session

Suppose you're marking a Chapter VI Neighbourhood Scene from a Year 9 student. You open their playground and see:

• Structure: main routine with 8 function calls. Separate functions for drawHouse, drawFence, drawCar, drawTree.
• Main routine: readable. Places three houses, a fence, a car, and a tree. Coordinates look deliberate.
• drawHouse: takes a position parameter. Uses sub-functions for drawWall, drawRoof, drawDoor. Clean.
• drawFence: uses a for loop to place 5 fence posts using the accumulator pattern.
• Picture: three houses, a fence in front of them, a car on the road, a tree on the side. Roof is drawn before the chimney (wrong z-order; chimney is behind the roof).

Marking:

• Decomposition: 4. Excellent structure. Main routine is short; component functions are small; sub-functions are used.
• Correctness: 3. The chimney z-order bug is a mistake, but everything else works.
• Code quality: 4. Clean, readable, meaningful names.
• Creativity: 3. Completed the spec well; didn't add anything unusual. This is a "solid, proficient" creativity score, not a weakness.

Total: 14 out of 16. High. This student is at the top of a normal distribution.

Written comment: "Excellent structural decomposition: the main routine is short and easy to read, and the house, fence, and car are each their own function. One small bug to watch: the chimney is hidden behind the roof because the order of your function calls has the roof drawn after the chimney. Try swapping them. Your fence uses the accumulator pattern correctly. Great work."

Notice what the comment does: it praises what was done well, points to one specific thing to fix, and uses language the student and their parents can understand. No Swift jargon, no vague encouragement, no grading scale printed on the feedback.

How to adapt this rubric

If your school's reporting framework uses different criteria, you can map the four criteria in this rubric onto other frameworks easily:

• Australian Curriculum "Problem-solving and reasoning" maps onto Decomposition.
• Australian Curriculum "Understanding and fluency" maps onto Correctness.
• Digital Technologies "Producing designed solutions" maps onto Code quality.
• Any "Personal and social capability" maps onto Creativity and ownership.

If your school requires a single-number mark, the 16-point total converts cleanly to any percentage scale.

If your school requires a descriptive comment without a mark, use the criterion-by-criterion assessment as the structure of the comment. Four short paragraphs: one per criterion.

Links

• Assessment Strategies for the philosophy
• Progress Tracking for student-level checklists
• Sample Student Work for exemplars (coming after the first classroom run)
• Each chapter's teaching notes page for per-section advice