Teach Python to Year 9 Without Marking 30 Scripts

Practical KS3 routines for teaching Python without a marking pile: PRIMM, self-checking tasks, whole-class feedback, auto-marking and a six-lesson Year 9 unit.

Teach Python to Year 9 Without Marking 30 Scripts

By Yuness, qualified Computer Science teacher and former Head of KS5 Computer Science · Last reviewed 21 November 2026

You can teach Python well to Year 9 without marking 30 scripts. Build the feedback into the lesson instead of adding it afterwards. Use prediction tasks and quick checks so you can see understanding live. Give pupils self-checking tasks and auto-marked exercises so they know at once whether their code works. Then spend 15 minutes scanning the class's work for patterns and give whole-class feedback next lesson. This fits the Education Endowment Foundation's review of written marking, which suggested a simple mantra: "mark less, but mark better".

This guide is for KS3 Computing teachers in England, including non-specialists, and ends with a suggested six-lesson first unit.

Instead of…Try…Teacher time
Marking every script after the lessonA 15-minute scan for common errors, then whole-class feedbackAbout 15 minutes per class
Finding out at the end who didn't get itPredict-the-output questions on mini-whiteboards or a hinge questionA few minutes in the lesson
Checking each program yourselfSelf-checking tasks with test inputs and expected outputsSet up once, then reused
Writing the same correction 20 timesAuto-marked exercises plus a reteach of the most common mistakeMinimal once the tool is set up
A queue of hands upPair programming, a debugging routine and a visible "stuck" signalNone extra; it saves time in the room

Why marking every Python script is not worth the time

Workload is still high. In the Department for Education's Working lives of teachers and leaders wave 4 summary report (survey run January to May 2025, published November 2025), full-time teachers reported working an average of 50.1 hours a week. Only 26% of teachers and leaders agreed their workload was acceptable. 38% of teachers and middle leaders said they spent too much time marking or correcting pupils' work.

The research does not show that more marking leads to more learning. In 2016 the EEF published A marked improvement?, a review of the evidence on written marking by researchers at the University of Oxford. According to the EEF's summary of the review, the typical teacher was then spending around nine hours a week on marking, yet there was little good evidence about which marking approaches helped pupils progress. The Oxford summary pulls out several points that apply directly to programming:

  • Treat careless mistakes differently from misunderstandings. A careless slip can simply be marked as wrong. A misunderstanding is better tackled with hints or questions that lead the pupil back to the underlying idea.
  • Acknowledgement marking (marking that only shows the work has been seen) is unlikely to help pupils progress.
  • Pupils only benefit from feedback if they are given time to think about it and act on it.

The EEF's later guidance report, Teacher Feedback to Improve Pupil Learning, deliberately steps away from the "written or verbal" debate and concentrates on the principles of good feedback. Its first three recommendations are to lay the foundations with high-quality teaching and careful formative assessment, to time feedback so it moves learning forward, and to plan how pupils will receive and use it. A Durrington Research School summary notes the report's point that extensive written feedback may have a large opportunity cost.

Programming time is also short. Ofsted's 2022 computing research review cited a report based on government census data which found that KS3 computing time fell from an hour to just over 45 minutes between 2012 and 2017. In a spring 2024 survey covering 108 schools, King's College London researchers found that most state schools spent 0–25% of KS3 lesson time on programming, while independent schools typically spent 25–50%. With so little time, feedback has to happen inside the lesson, where pupils can act on it straight away.

What the research says about teaching programming

The National Centre for Computing Education (NCCE) sets out 12 principles of computing pedagogy, and the Raspberry Pi Foundation publishes short "Quick Read" summaries of the research behind them. These are the approaches that matter most for a first Python unit. Each one also reduces marking.

PRIMM: Predict, Run, Investigate, Modify, Make

The PRIMM Quick Read describes five stages. Pupils predict what a program does, run it to check, investigate it through tracing and explaining, modify it in small steps, then make a new program using the same structures. It cites a 2018 study with around 500 learners aged 11–14 that found better outcomes after 8–12 weeks of PRIMM-based lessons. It also recommends keeping predictions low stakes and unassessed. In the KCL survey, PRIMM was the most common approach teachers reported using.

Why it cuts marking: predictions are written on paper or whiteboards before anyone touches a keyboard, so you see misunderstandings in the room rather than in 30 broken programs later.

Worked examples

The worked examples Quick Read suggests alternating examples with practice, labelling the subgoals in the code and fading support from complete examples to partial ones, then to independent problems. It also suggests using at least two examples per pattern, in different contexts.

Live coding

The live coding Quick Read recommends writing code in front of the class rather than pasting a finished solution. Make deliberate mistakes and fix them out loud, ask for predictions before running, and go slowly.

Parsons problems

A Parsons problem gives pupils all the lines of a working program in the wrong order to rearrange. The Parsons problems Quick Read notes that they reduce cognitive load, avoid syntax errors and make misconceptions easier to spot. It notes that adding distractor lines gives more confident learners extra challenge, but can also increase cognitive load. Ofsted's review adds that digital Parsons platforms can give pupils immediate feedback.

Pair programming

In the pair programming Quick Read, one pupil is the "driver" who types and the other is the "navigator" who checks and plans. Swap roles every 5–10 minutes and plan pairings in advance. When it comes to assessment, weight individual work more heavily than paired work.

Semantic waves

The semantic waves Quick Read describes "unpacking" a technical idea with an analogy, then "repacking" it into precise language. For variables, it suggests boxes and props, then tracing real Python assignments. The risk is a class that enjoys the analogy but never gets back to the code.

A lesson structure that builds feedback in

A reusable 50–60 minute structure; adjust the timings to your timetable.

  1. Retrieval starter (5 minutes). Three short questions from previous lessons, such as "What does this line print?" Pupils self-mark from the board.
  2. Feedback fix (5–8 minutes). Show one anonymised common error from last lesson's scan. The class fixes it together, then each pupil checks their own code for the same issue.
  3. Predict and run (10 minutes). Show a short program. Pupils write their prediction on mini-whiteboards, then you run it. Count the wrong answers in the room.
  4. Live code or worked example (10 minutes). Model the new idea, make a deliberate mistake, and label the steps.
  5. Investigate and modify (15 minutes). Pupils work in pairs on scaffolded tasks that move from "change one line" to "add a feature". Every task has expected outputs so pupils can check their own work.
  6. Exit check (5 minutes). One trace or Parsons question answered individually. This is the work you scan, not the full programs.

Low-stakes checks that tell you more than a marked script

A finished program shows what a pupil produced, possibly with help. A well-chosen question shows what they understand, and takes seconds to read.

Hinge question: predict the output

Show this program and give four options:

  1. x = 4
  2. y = x + 3
  3. x = 10
  4. print(y)

Options: A) 7, B) 13, C) 10, D) y. Pupils hold up fingers or write the letter. The answer is 7. A pupil who picks 13 is treating y as if it updates whenever x changes. A pupil who picks D is confusing a variable name with text. Each wrong answer tells you exactly what to reteach.

Parsons problem on paper

Print the lines of a short program on strips or as a numbered list. Pupils write down the correct order. You can check a whole class in under a minute because there is only one right sequence.

"Find the bug" exit ticket

Give a four-line program with one error and ask pupils to circle the line and write the fix. Sort the tickets into three piles: got it, partly, not yet. The piles become your seating and support plan for next lesson.

Explain in a sentence

"What does int() do in age = int(input("Age? "))?" One sentence, no code. This checks understanding rather than copying.

Whole-class feedback instead of individual marking

Use this routine once per lesson or once per week, depending on your timetable.

  1. Scan, don't mark (about 15 minutes). Look through the exit checks, or the error summary from an auto-marking tool. Don't write on anything.
  2. Fill in one sheet. Write down two or three things the class did well, the two or three most common errors, the names of pupils to check in with first, and one model answer.
  3. Sort errors into slips and misunderstandings. This follows the Oxford review. A missing colon or a misspelt print is a slip, so just flag it. Thinking that input() gives back a number is a misunderstanding, so it needs a question or a quick reteach.
  4. Give feedback at the start of the next lesson. Show the sheet, live-fix one error, and give pupils protected time to correct their own code. This is the "time to respond" the evidence says matters.

If your school's feedback policy asks for evidence in books or folders, a printed whole-class sheet with each pupil's correction underneath may cover it. Check your policy first.

Self-checking tasks: let the expected output do the marking

Every practical task should tell pupils how to know they're done. The simplest version is a test table printed under the task. Here is one for a program that asks for an age and prints "Child" if the age is under 13, "Teen" if it is 13 to 19, and "Adult" otherwise:

Type thisYour program should print
12Child
13Teen
19Teen
20Adult

Pupils tick each row when their program matches. The values on either side of 13 and 19 catch the classic < versus <= errors. This is also an early taste of the testing ideas pupils will meet at GCSE (see our GCSE guide to robust programs and testing).

Other self-checking formats:

  • Screenshot of the expected run next to the task, so pupils compare it line by line.
  • "Unlock" codes: the correct output of a program is the password for the next task.
  • Predict, then verify: pupils write their prediction before running, and the run itself is the feedback.

Using auto-marking tools (and what they can't do)

Auto-marking takes self-checking a step further. Pupils submit code and get an immediate verdict, and you get a view across the class. There are a few free options to know about, as of November 2026:

  • Shuttle's free Python platform for schools. Pupils write real Python in the browser with nothing to install. Every answer is marked as soon as it is submitted, with feedback that points to the exact mistake and suggests a next step. A "Summarise" button shows the teacher the most common mistakes and where each pupil got stuck, which feeds straight into the whole-class feedback sheet above. It covers GCSE, A Level and IB, and is free for schools, which are onboarded one at a time through the form at /schools. It is described as covering those qualifications rather than KS3 specifically, so check the exercises against your Year 9 scheme of work.
  • Ada Computer Science, from the Raspberry Pi Foundation and the University of Cambridge, is free. At its launch in March 2023 it had nearly 1,000 automatically marked questions that teachers could set as assignments and track in a markbook. It is aimed at GCSE and A level, so it suits older or faster-moving Year 9 groups.
  • Code Classroom (formerly the Code Editor for Education) from the Raspberry Pi Foundation is free and includes a Python editor. According to the October 2026 announcement, teachers can create classes, assign work and track progress. That post does not describe automatic marking.
  • Your school's quiz tool. Predict-the-output and Parsons-style multiple-choice questions work in any quiz tool that marks itself.

If you used Trinket, our comparison of free Python platforms for schools after Trinket's closure goes into more detail.

Auto-marking checks whether a program produces the right output, not whether the pupil understands why. Pair auto-marked tasks with the individual exit checks above, and treat the class summary as a starting point for your teaching, not a grade.

How to spot who's stuck without a queue of hands

  • Make "stuck" visible. Use a coloured card or cup on the desk, or a sticky note on the monitor. Then you can see the room at a glance instead of answering hands in order.
  • Read the error, then walk. Teach pupils to read the last line of a Python error message aloud to their partner before asking you. Our post on debugging routines for the hands-up problem sets out a full routine.
  • Circulate with the exit-ticket piles. Visit last lesson's "not yet" pupils in the first ten minutes of practical work.
  • Use the navigator. In pairs, the navigator's job includes spotting errors, so many problems get solved before they reach you.
  • Use the class summary. If your tool shows where each pupil got stuck, check it mid-lesson as well as at the end.

A suggested six-lesson first Python unit for Year 9

This is a suggested outline, not an official scheme of work. Adapt it to your pupils' prior experience, for example whether they used a block-based language in Years 7 and 8. Each lesson follows the structure above.

LessonFocusKey activityLow-stakes check
1Output and sequence: print(), strings, running codePRIMM on a three-line program, then pupils modify the messagesParsons problem: put five print lines in the right order
2Variables and assignmentSemantic wave: labelled boxes, then trace Python assignments line by lineThe x/y hinge question above
3Input and data types: input(), int()Live code a "how old will you be in 2030?" program, deliberately leaving out int() first to show the errorExplain in a sentence what int() does
4Selection: if, elif, else and comparison operatorsWorked example then a partial example; the age program with its test tableFind the bug: a < that should be <=
5Count-controlled iteration: for and range()Predict the output of range(1, 5), then modify a times-table programPredict how many times a loop runs
6Condition-controlled iteration: while, plus a small "make" taskPair programming: a password checker or number-guessing game combining everything so farIndividual Parsons problem with indentation; whole-class feedback in the next lesson

In this unit, the only work you look at closely is the exit checks, plus the class summary if you use an auto-marking tool. The Lesson 6 program can be peer-reviewed against a short checklist, such as: does it run, does it pass the test table, are the variable names meaningful? Save your detailed reading for one carefully chosen task at the end of the unit.

Pupils going on to GCSE will build on exactly these constructs. Our GCSE programming guide shows where they lead.

FAQ

Do I need to mark Year 9 Python work at all?

You need to know what pupils understand. That doesn't require written comments on every program. The EEF-published review of written marking found little robust evidence about which types of marking improve progress, and it suggested marking fewer pieces of work but marking them better. Check your school's feedback policy, then use exit checks, whole-class feedback and self-checking tasks for most lessons.

Is it enough to teach Scratch at KS3?

No. The national curriculum computing programmes of study require pupils at KS3 to use two or more programming languages, at least one of them textual. Ofsted's computing research review notes that this is the only requirement the curriculum sets about which languages to use. The KCL survey found Python was used by over 90% of schools surveyed at KS3 and KS4.

I'm not a Computing specialist. Where should I start?

Start with PRIMM and worked examples. Both give you a ready-made program to work from rather than a blank screen. The NCCE's pedagogy page links to short Quick Reads on each approach. Learn each lesson's program well enough to predict its output yourself before you teach it.

Can auto-marking replace teacher feedback?

Not completely. It tells pupils immediately whether their code works, and a good tool shows you patterns across the class. But it can't tell whether a pupil understands their own program. Use it to decide what to reteach, and keep individual checks such as tracing and explaining.

How much time do schools spend on programming at KS3?

It varies widely. In King's College London's 2024 survey, most state schools spent 0–25% of KS3 lesson time on programming, and independent schools typically spent 25–50%.

If you want a free way to put the auto-marking and class summary parts of this into practice, you can request access to Shuttle's Python platform for your school at /schools. Schools are onboarded one at a time, and the routines above work with or without it.