You Finished the Tutorial. Do You Actually Know It?

You watched the lesson and typed the code, and it ran. You feel like you know functions now — until a classmate asks you to explain one, and the words will not come. That is not a memory problem. It is the difference between recognising code and understanding it: following along proves you can copy, and nothing in a tutorial checks whether you could rebuild the idea from scratch.

Every student has felt this. You re-read the same lesson three times, and each time it feels clearer — until the blank file opens and the clarity evaporates. More tutorials do not fix a gap in understanding; they postpone discovering it. What fixes it is being forced to produce the idea yourself, in your own words.

Teaching Is the Test You Cannot Fake

Explaining is the oldest study trick there is, and it works because it is unforgiving. When you teach, you choose the words and say what happens in the cases nobody showed you. If your understanding has a hole, your explanation has one in the same place. That is the test: can someone else use your explanation on a problem you did not hand them?

The trouble is finding that listener. A classmate will nod politely and fill in your gaps from their own knowledge. A teacher will correct you, but that is their judgement, not proof. What you need is a listener who takes your words literally: who tries only what you taught and fails where your teaching failed. That is what the Teach-Back Apprentice in CoderFile Lab is built to do.

How the Apprentice Works: One Concept, Ten Minutes

Open your Apprentice and pick one concept: variables and conditions, loops, lists, or functions — or type in your own, like "Dictionaries". Each session is a ten-minute focus session, and the timer is a goal, not a lock: when it runs out, nothing closes. Your Apprentice starts knowing nothing about the concept. Teach it in your own words, with a small example in code.

Then it tries. Your Apprentice attempts a brand-new problem on that concept using only what you taught it, and the exact checks stay hidden until after it tries. Pass, and you level the concept up, from 0 to 3. Fail, and the failure names the gap: one specific sentence about the piece your teaching was missing. You reteach, adding the missing case to your example, and try again until it passes. That loop — teach, try, diagnose, reteach — is where the learning happens.

One honest note: the Apprentice is a guided simulator, not a real student. Its checks are fixed, it cannot improvise, and it learns nothing except what you put into the session. That is a limit, and the feature says so on the page. But for testing your understanding, the limit is an advantage: a real student might guess or be polite, while the simulator fails cleanly, where your teaching failed.

What Good Teaching Looks Like

Most first attempts fail the same way: the student teaches the happy path and forgets the edges. They explain what the code does when everything goes right, and say nothing about the empty list or the single item. The Apprentice then fails on exactly those cases — and the gap it names is the lesson. Good teaching names three things: what the code takes in, what it gives back, and the edge case. The example below passes, and you can run it in the browser editor first.

# teach_average.py — the example you teach your Apprentice with
def average(scores): """Return the mean of a list of numbers, or 0.0 for an empty list.""" if not scores: return 0.0 return sum(scores) / len(scores) print(average([80, 90, 100])) # 90.0
print(average([])) # 0.0
print(average([50])) # 50.0

The three prints are 90.0, 0.0, and 50.0 — and the teaching that goes with them is one paragraph, not one line. "It takes a list of numbers. It gives back their mean. If the list is empty, there is no mean to take, so it gives back 0.0 instead of crashing." That last sentence is the one most students leave out, and it is the one the hidden checks will test: an Apprentice taught only "add them up and divide" divides by zero on an empty list. Teach the edge case first.

When It Fails, Read the Gap, Not the Grade

A failed attempt feels like a verdict, and students treat it like one: they rewrite the whole explanation, or decide the concept is too hard. Both reactions waste the best part of the session. The failure is not a grade — it is a diagnosis, pointing at one missing piece. Change that piece and nothing else: add the sentence about the empty list, add the case to your example, and try again. Most students pass on the second or third attempt.

The same rule applies in reverse. If your Apprentice passes on the first try, ask whether your teaching was good or your example was just easy to copy. A pass after a real explanation is worth trusting. A pass on a copied example is not, and the next concept will expose it. The honest signal is not the level number — it is whether you could teach the same concept to a classmate without the screen in front of you.

The Three-Day Nudge and the Teaching Portfolio

Learning fades, and the Apprentice knows it. If you have not revisited a concept for three days, it says it is starting to forget it and asks you to reteach it in two minutes. That nudge is the cheapest revision you will ever do: two minutes of explaining beats an hour of re-reading, because explaining rebuilds the idea instead of recognising it. Come back, reteach the concept in your own words, and the level holds.

There is a second payoff. When your Apprentice passes, you can save your teaching as a snippet — your explanation and your example, kept as proof you understood the concept well enough to teach it. Custom concepts can be saved too, after an attempt, even though they have no hidden checks and no level-up. The lesson page links to the matching Apprentice concept when you finish a lesson, so the loop is one click.

When Your Teaching Portfolio Outgrows Free, That Is the Upgrade Moment

Stay on Free ($0: 20 executions a day, 10 AI requests a day, 10 saved snippets, 3 private snippets, 3 collaborators per snippet) while it fits — teaching four concepts and saving the best ones fits easily. But a teaching portfolio grows by design: every concept you prove becomes a saved snippet, and ten fills up fast. That is when Pro earns its $9/month or $69/year — unlimited saved snippets and executions, 100 AI requests a day, 10 collaborators per snippet, and GitHub integration, which Free does not include. Team ($19/user/month, or $15/user/month billed annually) covers a class teaching concepts to each other.

Your next step takes ten minutes, and it starts tonight. Finish one Lab lesson and follow its link to the matching Apprentice concept — or open your Apprentice now, pick functions, and teach it the average example from this article. When it fails, read the gap, fix one sentence, and try again. Then save the teaching as a snippet. That saved snippet is the proof: you do not just know functions, you can teach them.