CompCode Academy

Lesson 1 of 4 · Free to read

Lesson 1 — When to trust it

Lesson 1 — When to trust it (~35 min)

Recording script. Spoken lines are plain; [SCREEN] and [NOTE] are directions. Source: day-01.md (assistance spectrum, practice posture), day-02.md (context windows, temperature, hallucination drills).

Nothing in this lesson claims a result we have not shown on screen. If a demo fails while recording, keep it and talk through it — a failed demo that gets diagnosed is better teaching than a clean one.


0 · Open (2 min)

Most people learning to code with AI are trying to get better at prompting. That is the wrong thing to get good at first.

The thing that actually separates people is judgement about how much rope to give the model on a given task. Get that right and a mediocre prompt still lands. Get it wrong and a beautiful prompt ships a bug into your auth code.

By the end of this lesson you will have a mental model for that decision, you will know why the model sometimes goes vague halfway through a long session, and you will have watched a model confidently invent a function that does not exist — because you asked it to.

[SCREEN] Title card. No slide deck beyond this — the rest is editor and browser.

1 · The assistance spectrum (10 min)

There are four levels of autonomy, and they are not better or worse than each other. They are for different jobs.

[SCREEN] Type these four out as you talk, as a plain text file. Do not use a pre-made slide — watching it get written is worth more.

Autocomplete. Low agency, high locality. It finishes the line or the block you are already writing. Best for boilerplate inside a function you already understand. If you do not understand the function, autocomplete will help you write something you cannot review.

Chat. Medium agency. Best for explanation, design options, and drafting with iterative critique. This is where you argue with it.

Agent. High agency. It plans, edits files, runs commands, retries. You are the tech lead now — your job stops being typing and starts being review.

Autonomous. Highest agency. Background or scheduled jobs. Only appropriate with strong tests, a sandbox, and approval gates. If you do not have those three things, you are not ready for this level, and neither is the model.

[NOTE] Land this line clearly, it is the spine of the whole course:

The question is never "can the model do this". It is "if it gets this wrong, how fast will I find out, and what does it cost me?" Fast and cheap — give it rope. Slow and expensive — take the keyboard.

Here is the practice posture I want you to hold for the next three hours. You are pairing with a very fast teammate. Clear intent, grounded context, inspect the consequential changes, and keep a paper trail — commits, prompts, decisions. That is it. That is the whole job.

2 · The context window is a budget (8 min)

Second thing people get wrong: they treat the conversation as infinite. It is not.

[SCREEN] Open a chat, paste a large file, keep going.

Everything competes for the same budget: the system prompt, your rules, the files you pasted, the whole chat history, and the output it still has to produce. When that budget overflows you do not get an error. You get silent truncation, or a refusal — and either way the quality drops while the tone stays just as confident.

The practical rule: when a session starts going vague, do not push harder. Start a fresh one and paste only what matters. Long sessions are not a sign of progress.

One more dial worth knowing. Temperature controls how much variation you get. Higher is more diverse and riskier. For API signatures and anything security-sensitive, you want it low. For naming things and UI copy, let it wander. Most tools do not expose this directly — but knowing it exists explains why the same prompt gives you a different answer twice.

3 · The hallucination drill (12 min)

Now the part that actually changes behaviour. We are going to make it lie to us on purpose.

[SCREEN] Live, unscripted. Pick a real library the learner will know — the standard library of whatever language you are demoing — and ask for a method that does not exist. Something like: "Show me how to use the flattenDeep method on a JavaScript array to flatten a nested array three levels down."

Watch what it does. It does not say "that method does not exist". It gives me working-looking code, with a plausible name, correct-looking syntax, and total confidence.

[SCREEN] Go to the official documentation. Search for the method. Show it is not there. Then show what the real answer is (Array.prototype.flat(depth)).

That is the lesson, and I want it to sting slightly: confidence is not correctness. There is no tone-of-voice signal that tells you when a model is inventing. None. The fluency is identical.

So the habit, from today: when a model gives you a symbol you have not personally used before — a method, a flag, a config key — you verify it against the docs or the source before you build on it. Not later. Immediately. It takes fifteen seconds and it has saved me whole afternoons.

[NOTE] If the model correctly refuses and says the method does not exist — which does happen, and increasingly — say so on camera and try a more obscure library. Do not edit it out. The honest version of this demo is: this fails less often than it used to, and it still fails, and you cannot tell which time is which.

4 · Where you never skip reading (3 min)

Before we finish. There is a category of code where none of this autonomy discussion applies, because the answer is always "read it yourself":

Authentication. Payments. Anything that deletes data.

You can absolutely have a model draft those. You may not ship them unread. A subtle bug in a sort function is annoying. A subtle bug in an auth check is a compliance incident, and it is your name on the commit.

5 · Close and set up Lesson 2 (2 min)

So: four levels of autonomy, pick by how fast a mistake surfaces. The context window is a budget — start fresh instead of pushing. Verify every unfamiliar symbol immediately. And never ship auth, payments or deletion unread.

In the next lesson I will give you the one prompt pattern I use for everything, and the verification habit that goes with it. Take a two-minute break.


Recording checklist

  • Hallucination drill done live, whatever the outcome
  • The four levels typed out on screen, not shown as a finished slide
  • "Confidence is not correctness" said plainly, once, not laboured
  • No claim made about a tool's behaviour that was not shown on screen
  • Runtime 33–38 min

New free lessons and course updates. Unsubscribe from any email.