Every concept on this page is the kind of thing a parent might pay a separate course for. We do not charge separately and we do not teach it separately. The studio is built so each concept fires the first time a kid bumps into it in their own project — a wisdom moment, a transparency quest, a vocabulary card — and is reinforced every time after.
1. Prompt steering.
The word a kid changes is the answer that changes. Theo wrote "make it harder" three times before learning to specify which harder — speed, telegraph, or second phase. The studio surfaces this the first time a kid’s vague prompt produces a wrong-feeling result and they have to revise.
The "say it more specifically" moment.
Surfaces: First time the AI’s output doesn’t match what the kid imagined.
Inkie offers to rephrase the request together. The kid sees the difference between "make it scary" and "make it scary by adding a slow-mo telegraph and a flash on near-miss." The same project ends up better.
"AIs are never the same twice. When you change one word, the answer moves."
2. Tool use.
Every AI change is a file edit the kid can see. Inkie’s edit_file tool runs visibly — the kid watches the file get read, the diff get proposed, the new lines land. Kids stop seeing AI as magic and start seeing it as a worker with hands.
The "wait, it’s doing something" moment.
Surfaces: First time a wizard runs and the kid watches the tool-trace pane.
The tool-trace shows real action: reading icarus.html, proposing 1 change to player.update(), adding new function checkSunDamage(). The kid can read along. No more "the AI did it."
"Tools are how the AI reads, edits, and checks your real files."
3. AI mistakes & hallucination.
The first time Inkie invents a file that doesn’t exist, the kid notices. The transparency quest "find a mistake" turns that noticing into a habit. Every project produces at least one obviously-wrong AI proposal; that moment is the most important AI-literacy lesson kids learn.
The "that’s wrong" moment.
Surfaces: The first confidently-wrong AI proposal.
The kid sees Inkie propose a change to a function that doesn’t exist, or reference a variable spelled differently, or assert a fact about the game world that isn’t true. Inkie says "look at me" in plain English — and then asks the kid to point at the wrong thing.
"AI can sound confident and still be wrong. So you check the result."
4. Project context.
Naming the file, the scene, the character is the difference between a good AI change and a wrong one. Kids learn to name the target. "Update the sage" is a different prompt than "update the character" — and the studio teaches that distinction the first time the wrong character gets edited.
The "tell it which one" moment.
Surfaces: First time the AI edits the wrong file because the kid didn’t specify.
Inkie shows the kid the file that was changed and asks if it was the right one. If not, Inkie suggests the prompt template: "In scene-03.html, change the sage’s line…"
"Tell the AI what file, scene, page, or rule you mean."
5. Iteration.
Theo undid 18 changes across four games. Each undo taught him to ask better the next time. Iteration becomes muscle, not lecture — and the studio’s Keep / Review / Undo loop is built to make iteration feel like the move, not the failure.
The "try the second version" moment.
Surfaces: First time the kid takes Inkie’s second proposal over the first.
Theo did it on Perseus — Inkie’s first mirror proposal (a rear-view inset) "felt like a video game." The second (a real in-world mirror) was the keeper. The studio surfaces this as a transparency quest.
"Good AI work often takes tries. Ask, inspect, redirect, improve."
6. Custom instructions.
By 12, kids are writing GAMEPLAN.md files that hold project instructions the AI follows every session. Real software practice. The studio surfaces this the first time the kid says "stop suggesting that" twice — Inkie offers to write the kid’s preference into a project-instructions file.
The "write it down once" moment.
Surfaces: First time the kid corrects Inkie on the same kind of thing twice.
The kid says "don’t add ads to the game" twice. Inkie says "want me to write that into the project instructions so I never suggest it again?" The kid says yes. A markdown file is born.
"Tell the AI to keep controls simple and never add surprise ads."
7. AI variation.
Same prompt, different answer. Run the same wizard twice and Inkie proposes two different changes. The studio surfaces this as a transparency quest: "Same prompt, two answers." Kids learn that AI is probabilistic, not deterministic — and that the right move is to ask for several proposals and pick.
The "wait, it gave a different answer this time" moment.
Surfaces: The "Same prompt, two answers" transparency quest (+25xp).
Inkie offers the same wizard twice. The kid sees two different proposals. The studio shows them side by side. Kids never again treat the AI’s first answer as the only answer.
"Ask the same question twice. The answers tell you which parts are guesses."
8. Safety filters.
The two-layer safety filter is invisible until something is blocked. When it is, the kid sees a friendly message; the parent gets an email; the safety log records it. The kid learns that filters are a real piece of how AI gets deployed, not a piece of magic that vanishes once they’re old enough.
The "why didn’t it answer" moment.
Surfaces: First filter block. Full mechanics at /parents/safety.
The kid tries to do something the filter catches. Inkie says "that’s outside the safety setting for this account." The kid learns that filters exist, that they’re configurable, and that they sit between the kid and the AI on every request.
"Safety filters live on the server. Adults choose where they sit."
9. Trade-offs.
Every Keep / Review / Undo decision is a small trade-off. The "ask for more time" feature is a trade-off. The G vs. PG-13 rating is a trade-off. The studio surfaces trade-offs as named choices instead of hiding them as silent defaults.
The "you can’t have both" moment.
Surfaces: Every wizard with mutually-exclusive proposals.
The kid wants the enemy to feel faster and easier. Inkie shows the trade-off curve: more speed = more difficulty unless the telegraph is also longer. The kid learns to name the second variable to compensate.
"Make the harder thing easier by changing two settings, not one."
11. Decomposition.
"Make the scorpion harder" became three asks: speed, telegraph, second phase. The studio surfaces decomposition by asking "harder how?" instead of guessing. Kids learn that big asks have to be broken into specific ones — the most transferable software-engineering move there is.
The "harder how?" moment.
Surfaces: First multi-axis request.
Theo’s Orion was the project. He learned that the AI’s clarifying question wasn’t a stall — it was the move that produced the right outcome.
"Hard prompts are three small prompts you haven’t separated yet."
12. Reviewing AI work.
Every change shows up in a change-summary card in the chat before it lands — the changed files, the changed objects, a one-line "why" written by Inkie. The preview reloads to show the new state. Reviewing AI work becomes muscle. Kids who learn this at nine carry it for life.
The "let me actually try it" moment.
Surfaces: Every Keep / Review / Undo decision. Every wizard. Every prompt.
The studio refuses to let the kid keep a change without seeing it run. The change-summary card pairs with the preview reload — together they’re the most-used affordance in the whole studio.
"AI work is reviewed work. The author is the reviewer."
13. Vocabulary cards.
Roughly thirty named terms that surface as cards the first time a kid bumps into them. Prompt. Wizard. Tool. Diff. Snapshot. Branch. Approval. Publish. Threshold. Hit-box. Each card has a one-line plain-English definition and a real example from the kid’s own project.
By the end of a few projects, a kid can use the vocabulary correctly in a sentence without ever having been quizzed on it. The cards live in the studio sidebar, browsable, never hidden.
Five categories.
Surfaces: First instance of each term in the kid’s own work.
- AI primitives — prompt, response, wizard, tool, model.
- Project primitives — file, scene, level, page, branch.
- Maker-loop primitives — propose, change, snapshot, keep, review, undo, publish.
- Safety primitives — filter, category, rating, log.
- Craft primitives — iteration, decomposition, taste, voice.
Last updated 2026-05-16. New concepts and quests added as kids surface them.