Choosing a difficulty level (Beginner / Intermediate / Advanced)

The wizard's Difficulty selector offers three options: Beginner, Intermediate, Advanced. They look like they're just about code complexity. They aren't. Difficulty actually controls how much working code appears in the student-facing Instructions.md — which means it controls how much hand-holding your students get.

Pick this wrong and you ship the wrong assignment regardless of how clever the code or tests are. Beginner students staring at "no code, just requirements" will get stuck and frustrated; advanced students reading "here is the complete solution" will be bored and learn nothing. Read this article before clicking Generate.

What each level actually does to Instructions.md

Instructions.md is what students read when they open your assignment. It always has the same structure (Overview, Learning Objectives, Getting Started, Implementation Steps, Complete Program, Testing, Grading Rubric, Tips and Hints). Difficulty controls the Implementation Steps and Complete Program sections — specifically, how much code the AI shows.

Same starter, same tests, same point values across all three. The only thing that changes is how much the document holds the student's hand.

Concrete examples — same task, three levels

For a beginner Python assignment that asks students to write a function returning the sum of a list:

Implementation Steps

Task 1: Implement sum_list(numbers)

Write a function that takes a list of numbers and returns their sum.

def sum_list(numbers):    total = 0    for n in numbers:        total += n    return total

This loop starts a running total at 0, then adds each number from the list to it…

The same task at intermediate:

Implementation Steps

Task 1: Implement sum_list(numbers)

Write a function that takes a list of numbers and returns their sum.

Pseudocode:

initialize total to 0for each number in the list:  add it to totalreturn total

Hint: Python's for loop iterates over a list directly — for n in numbers:.

And at advanced:

Implementation Steps

Task 1: Implement sum_list(numbers)

Write a function that takes a list of numbers and returns their sum. The function must handle empty lists (return 0) and lists of arbitrary length. Time complexity should be O(n).

Same problem. Three completely different student experiences. You're picking the experience.

How to pick

Match the level to where your students are right now, not where you wish they were.

Pick Beginner when:

• Students are in their first programming course
• The semester is in its first 4–6 weeks
• The concept is brand new to most students (recursion, OOP, async)
• You want students to focus on reading and understanding code rather than producing it from scratch
• You're using the assignment as a worked example before a harder follow-up

Pick Intermediate when:

• Students have written similar code before but maybe not exactly this
• You want them to think through the structure but not invent the algorithm
• The lesson is about a technique (a specific data structure or pattern) rather than open-ended problem-solving
• You're comfortable with some students needing TA help

Pick Advanced when:

• Students should be able to design the solution themselves
• The lesson is about decomposition, design choices, or trade-offs — there's more than one right answer
• You want to assess whether students can apply concepts rather than just execute steps
• The class is upper-division or graduate-level

The Difficulty selector also affects code complexity

Beyond Instructions.md, Difficulty also nudges the generated solution toward different complexity levels:

• Beginner — clean, simple code using basic constructs; comments explaining logic; no advanced patterns or optimisations
• Intermediate — balanced code; some helper functions; reasonable patterns
• Advanced — idiomatic, possibly more compact code; advanced language features; less commentary

This matters most in Backward mode (where the AI strips your solution into a starter — the strip aggressiveness scales with level) and From Document mode (where the AI invents the whole solution).

Can I mix levels within an assignment?

Not directly per-task — Difficulty is a single choice per assignment. But two workarounds:

Edit Instructions.md by hand on the Review step. Pick the level that fits most of the assignment, then on the Instructions tab, manually beef up or strip down individual task sections.

Split into multiple assignments. If part of the lab is genuinely beginner and part is genuinely advanced, generate two separate assignments and link them in your Classroom (e.g., "Lab 5a — Foundations" and "Lab 5b — Extensions").

Re-running with a different level after generation

Already generated and the level feels wrong? You don't have to start over:

• On the Instructions tab of Review, click Regenerate in the top right. It re-runs only the Instructions.md generation, this time at whatever Difficulty you've selected. Starter, solution, and tests are unaffected. Costs one credit.

If you want to change the code complexity of the solution too, you'd need to re-run the whole assignment from scratch. Either generate a new assignment with the same inputs, or go to the Seed step (click Seed in the progress bar), change the Difficulty, then click Generate again.

TL;DR — quick lookup

When in doubt, start one level easier than you think. You can always crank it up next assignment.

Where to go next

• Picked your difficulty? → Back to the wizard and click Generate.
• Already generated and the level feels wrong? → Open the Instructions tab on Review and click Regenerate (or change Difficulty in the Seed step and regenerate the whole thing).
• Want to see what each level looks like in practice? → Generate the same assignment three times (one per level) on a throwaway repo and compare the Instructions.md outputs side by side.