The GenKid pathway

You'll be able to…

• Explain what AI is, with examples and non-examples, and that people design and build it.
• Describe how AI learns patterns from training data and uses them to make predictions.
• Explain that chatbots generate text by predicting likely next words, not by understanding like a person.
• Write a clear prompt with a goal, context and constraints — and no personal information.
• Decide where AI can help, where it can't, and when to ask a trusted adult.

Lessons (5 written)

1. What is AI?
2. Learning from examples
3. How chatbots work
4. Writing good prompts
5. AI and me

Assessment

• Explains what AI is and correctly sorts examples and non-examples, giving reasons.
• Describes training data, patterns and predictions, and why varied, correctly labelled data matters.
• Explains that chatbots generate text by predicting likely next words, using non-human language.
• Writes prompts with a clear goal, context and constraints and no personal information.
• Identifies situations where AI can help, where it shouldn't be used, and when to ask a trusted adult.

To complete

• Complete all five lessons, including each activity.
• Pass each lesson check at 70% or higher (you can retry as often as you like).
• Pass the course check at 70% or higher.

You'll be able to…

• Recognise hallucinations — confident but wrong AI output — and explain why they happen.
• Explain how data and design choices can make AI unfair, and suggest sensible checks.
• Decide what information never to share with AI tools, and involve adults in settings.
• Give credit honestly, including for AI help, and explain the basics of who made something.
• Use verification habits: lateral reading, trusted sources, testing code, and deciding when not to use AI.

Lessons (5 written)

1. Confident but wrong: hallucinations
2. Bias and fairness
3. Privacy and your data
4. Credit, copyright and honesty
5. Check it! Verification habits

Assessment

• Identifies likely hallucinations and explains why language models produce them.
• Explains how training data and design choices can cause bias, and proposes practical checks.
• Rewrites prompts to remove personal information and explains what never to share.
• Gives honest credit for sources and AI help, following task rules.
• Applies verification habits — lateral reading, trusted sources, testing code — and the 'when not to use AI' checklist.

To complete

• Complete A1 AI Explorers first (recommended).
• Complete all five lessons, including each activity.
• Pass each lesson check at 70% or higher (you can retry as often as you like).
• Pass the course check at 70% or higher.

You'll be able to…

• Write precise, ordered instructions (an algorithm) for an everyday task.
• Break a big problem into smaller parts and spot repeating patterns.
• Explain choices (if/else) and repetition (loops), and read a tiny JavaScript example that uses them.
• Debug calmly: predict, test, isolate and fix, using error messages as clues.

Lessons (4 written)

1. Algorithms: precise steps in order
2. Decomposition and patterns
3. Choices and loops
4. The debugging mindset

Assessment

• Writes an ordered, unambiguous algorithm that another person can follow.
• Breaks a task into sensible parts and identifies repeating patterns.
• Correctly predicts the output of short if/else and loop examples.
• Uses predict–test–isolate–fix and reads an error message to locate a bug.

To complete

• Complete all 4 lessons.
• Pass each lesson check (70% or more).

You'll be able to…

• Structure a page with headings, paragraphs, lists, images and buttons.
• Style a page with CSS selectors, colours, spacing and fonts.
• Use variables and click events to change what a page shows.
• Make decisions in code with comparisons and if/else.
• Apply accessibility basics: alt text, contrast and clear button labels.

Lessons (5 written)

1. HTML: the structure of a page
2. CSS: making it look good
3. JavaScript: variables and click events
4. JavaScript logic: comparisons and if/else
5. Make it yours — for everyone

Projects

2 sandbox projects with automated checkpoints.

Assessment

• Uses correct, properly closed HTML elements for headings, paragraphs, lists, images and buttons.
• Writes valid CSS rules with element, class and id selectors.
• Uses variables, querySelector and click events to update the page.
• Uses comparisons and if/else correctly, including boundary values.
• Applies alt text, readable contrast and clear button labels.

To complete

• Complete all 5 lessons and pass each check (70% or more).
• Finish both projects: Fan Page for an Imaginary Creature and Click Counter, with all automated checks passing.
• Write a short reflection for each project.

You'll be able to…

• Explain responsible "vibe coding": the AI tool generates code, but you decide, check and understand.
• Write clear requests for code with a goal, constraints and a request for explanations.
• Read AI-generated code line by line, explain it back and spot risky or unneeded parts.
• Test AI-generated code with normal, edge and unexpected cases.
• Debug with an AI helper by sharing the error and relevant code (never secrets or personal information) and checking the fix.

Lessons (5 written)

1. What is vibe coding? (and how to stay in charge)
2. Asking for code well
3. Reading AI code line by line
4. Testing AI code
5. Debugging with an AI helper

Projects

2 sandbox projects with automated checkpoints.

Assessment

• Writes requests for code with a clear goal, constraints and a request for explanations, containing no personal information.
• Explains AI-generated code line by line and removes risky or unneeded code.
• Designs normal, edge and unexpected test cases and uses them to find mismatches with the goal.
• Debugs by sharing errors and relevant code safely, asks for hints first and verifies suggested fixes.
• Is honest about how the AI helper was used in project reflections.

To complete

• Complete all 5 lessons and pass each check (70% or more).
• Finish both projects: Fix the Buggy Quiz and Colour Mixer, with all automated checks passing.
• Write a reflection for each project that includes how the AI helper was used and what you checked yourself.

You'll be able to…

• Store app data in arrays and objects
• Write functions with parameters and return values
• Draw a list on the page from an array with a render function
• Read and validate form input using preventDefault
• Organise an app around one state object and render()

Lessons (5 written)

1. Arrays and objects: storing your app's data
2. Functions: reusable building blocks
3. Drawing the page from data
4. Forms, input and validation
5. App state: one source of truth

Projects

2 sandbox projects with automated checkpoints.

Assessment

• Lesson checks passed at 70% or above
• Project steps pass their automated checks
• Can explain, line by line, how render() draws the page from state
• Validates user input and shows messages in the page, not pop-ups

To complete

• Complete all five lessons
• Finish Mission List or Space Quiz Game with all checks passing
• Answer the project's reflection prompts

You'll be able to…

• Write user stories, a sketch and milestones, and a PLAN an AI helper can follow
• Build accessible apps with labels, contrast, keyboard-friendly controls and alt text
• Write test functions that check normal and edge cases
• Refactor with an AI helper while proving behaviour is unchanged
• Write an honest, anonymous project write-up

Lessons (5 written)

1. Planning an app before you code
2. Accessibility: apps everyone can use
3. Testing: proving your code works
4. Refactoring with an AI helper
5. Writing up your project honestly

Projects

2 sandbox projects with automated checkpoints.

Assessment

• Lesson checks passed at 70% or above
• Capstone includes a PLAN comment with user stories
• Capstone passes accessibility and test checks
• Write-up is honest about AI help and contains no personal information

To complete

• Complete all five lessons
• Finish Reaction Timer and the capstone with all checks passing
• Answer the reflection prompts for both projects

You'll be able to…

• Explain what API keys and tokens are and why they must never appear in code, chats or screenshots.
• Describe what to do if a secret leaks: tell an adult, revoke or rotate it, and check for misuse.
• Apply least privilege by choosing the smallest permissions a tool or key needs.
• Use versions and backups so mistakes can be undone.
• Publish safely using previews, tests, rollbacks and a clear idea of who can see a site.

Lessons (4 written)

1. Secrets: keys, tokens and passwords
2. Permissions and least privilege
3. Backups, versions and undo
4. Safe deploys: previews, tests and rollbacks

Assessment

• Explains why secrets must stay on a server and never appear in code, chats or screenshots.
• Describes the correct response to a leaked key (tell an adult, revoke or rotate, check for misuse).
• Chooses least-privilege permissions for a described task.
• Uses versions before risky changes and writes clear snapshot messages.
• Follows the preview, test, publish, roll back routine and checks for personal information.

To complete

• Pass all four lesson checks (70% or more).
• Complete the token builder and deploy simulator activities.

You'll be able to…

• Navigate folders and run commands in a terminal, and read their output.
• Create, copy, move and safely remove files, making a backup before risky changes.
• Explain what npm, packages and package.json are for.
• Start and stop a local development server and read its error messages.
• Use .env files, .env.example and .gitignore to keep secrets out of code.
• Check a package before installing it, and recognise risky install instructions.

Lessons (6 written)

1. What is a terminal?
2. Folders and files from the terminal
3. npm and package.json
4. Running a dev server
5. Environment variables in practice
6. Package safety

Assessment

• Completes the sandbox terminal tasks: navigating, creating, backing up and removing files.
• Explains each line of a simple package.json.
• Reads a dev server error and identifies the file, line and likely cause.
• Writes a .gitignore that keeps .env private while sharing .env.example.
• Identifies risky install instructions and look-alike package names.

To complete

• Pass each lesson check (70% or more).
• Complete the tasks in the sandbox terminal tryits.

You'll be able to…

• Create a repository, stage changes and make commits with clear messages.
• Read the history, compare versions and undo mistakes safely.
• Use branches to try ideas without breaking the working version, and merge them back.
• Explain what a pull request is and write a kind, specific review.
• Describe how teams collaborate through a remote repository, and what public versus private means.
• Keep secrets and personal information out of every commit.

Lessons (5 written)

1. Repositories and commits
2. History and undo
3. Branches
4. Pull requests and reviews
5. Collaborating on GitHub

Assessment

• Makes a series of meaningful commits in the sandbox, keeping .env out of history.
• Finds a bad commit using the log and undoes it with git revert.
• Creates, merges and explains a branch, and reads a merge conflict.
• Writes a kind, specific pull request review that spots a secret and an accessibility problem.
• Explains push, pull and public versus private repositories.

To complete

• Pass each lesson check (70% or more).
• Complete the tasks in the Git sandbox and the branch visualiser challenge.

You'll be able to…

• Explain servers, static files, serverless functions, builds and deployments.
• Compare hosting platforms by the concepts they share rather than by brand.
• Use preview deployments to check changes, and describe how a rollback restores a working site.
• Keep secrets in a host's environment variables, separate for preview and production.
• Explain why account ownership, age rules and plan terms matter before publishing.

Lessons (5 written)

1. How hosting works
2. Platforms: Vercel, Netlify and Cloudflare Pages
3. Previews, production and rollbacks
4. Secrets on a host
5. Accounts, ages and terms

Assessment

• Explains the build-and-deploy pipeline and what happens when a step fails.
• Decides which parts of a site should be static files and which need a server function.
• Plans a safe deployment with a preview, a review and a rollback.
• Configures pretend environment variables with no public secrets and separate keys per environment.
• Identifies who should own the hosting account and what to check before publishing.

To complete

• Pass each lesson check (70% or more).
• Complete the preview-and-rollback simulator and get a clean report in the environment variables dashboard.

You'll be able to…

• Explain domain names, registrars, renewals and why the account holder matters.
• Spot look-alike domains used in phishing.
• Read common DNS records (A, AAAA, CNAME, MX, TXT, NS) and say what each does.
• Change DNS records safely: back up first, understand TTL and caching, and check the result.
• Explain what HTTPS and certificates protect, and what the padlock does not prove.
• Describe what a CDN, caching, rate limiting and firewall rules do.

Lessons (5 written)

1. What is a domain?
2. DNS records
3. Sandbox DNS simulator
4. HTTPS and certificates
5. CDNs and protection (Cloudflare concepts)

Assessment

• Identifies the real domain in an address and spots look-alikes.
• Correctly matches DNS records to their purposes and reads a record table.
• Fixes a misconfigured record in the simulator after saving a backup, and explains TTL and caching.
• Explains what HTTPS protects and what the padlock does not prove.
• Explains caching, purging, rate limiting and firewall rules.

To complete

• Pass each lesson check (70% or more).
• Complete the tasks in the DNS simulator.

You'll be able to…

• Design simple tables with columns, rows, keys and relationships.
• Read, add, change and remove rows safely, with backups and checks before risky changes.
• Explain authentication (who you are) versus authorisation (what you may do), and what a session is.
• Explain file storage, public versus private files, and short-lived links.
• Describe row-level security and why every table needs rules, and why secret database keys stay on a server.
• Explain data minimisation: collect only what an app needs and delete it when it is no longer needed.

Lessons (6 written)

1. Tables, rows and columns
2. Reading and writing data
3. Sign-in and sessions
4. File storage
5. Row-level security
6. Collect less data

Assessment

• Designs a sensible table schema with primary and foreign keys.
• Predicts which rows a query will touch and spots a missing where clause.
• Explains authentication versus authorisation and what 401 and 403 mean.
• Writes a row-level security rule in plain words and explains why secret keys stay on the server.
• Spots a data-minimisation problem in an app plan.

To complete

• Pass each lesson check (70% or more).
• Complete the query playground and row-level security simulator using fictional data.

You'll be able to…

• Explain the steps of an online payment: checkout, approval, confirmation and webhooks.
• Explain test mode, test keys and published test cards, and why they never move real money.
• Describe why secret and restricted payment keys must stay on a server, and which key may appear in browser code.
• Explain why webhooks must be verified and why duplicate events must not cause double orders.
• Explain consumer honesty: clear prices, easy cancelling and refunds, and no pressure tricks.

Lessons (5 written)

1. How online payments work
2. Test mode and sandboxes
3. Webhooks
4. Payment keys and safety
5. Honest prices and fair design

Assessment

• Explains a payment flow in order and why the server waits for the provider's message.
• Explains test mode and why published test cards never move real money.
• Identifies which keys may appear in browser code and which stay on a server.
• Explains signature verification and duplicate handling for webhooks.
• Spots a dishonest checkout design and suggests a fair alternative.

To complete

• Pass each lesson check (70% or more).
• Complete the test-mode checkout and webhook simulators.

You'll be able to…

• Explain text-to-speech (TTS), speech-to-text (STT) and speech-to-speech, and the difference between on-device and API voices.
• Compare voice providers fairly using features, pricing units, terms and safety, not just how impressive a demo sounds.
• Estimate costs from per-character and per-minute pricing and plan a budget with limits.
• Explain why voice cloning needs explicit consent, why children's voices are off-limits, and why AI voices should be disclosed.
• Describe a safe voice feature where the browser calls your own server and the provider key stays on that server.

Lessons (5 written)

1. How voice AI works
2. Comparing voice providers
3. Characters, minutes and budgets
4. Voices, consent and cloning
5. A voice feature in the sandbox

Assessment

• Explains TTS, STT and speech-to-speech, and on-device versus API voices.
• Compares two providers using fair, written criteria and treats terms as pass/fail requirements.
• Estimates a cost from a (fictional) pricing table and proposes budget protections.
• Explains consent, children's-voice and disclosure rules for voice AI.
• Describes a server-side proxy design that keeps keys on the server.

To complete

• Pass each lesson check (70% or more).
• Complete the on-device speech demo (or read its fallback) and the pretend voice server exercise.

You'll be able to…

• Explain what a virtual server (VPS) is and how it differs from physical servers and managed hosting.
• Explain SSH and key pairs, and why the private key never leaves your device.
• Choose least-privilege, expiring tokens for infrastructure tools and explain rotation.
• Describe containers, what they isolate, and why data that must survive lives in volumes and backups.
• Explain nodes, load balancing and a basic hardening checklist (updates, firewalls, key-only login, backups, monitoring).
• Explain how hosting providers bill, why accounts involve identity and payment checks, and why real accounts are adult-owned.

Lessons (6 written)

1. What is a server?
2. SSH and key pairs
3. Tokens and access control
4. Containers
5. Nodes and hardening
6. Hosting providers

Assessment

• Explains physical servers, VPSs and managed hosting, and who is responsible for what.
• Explains public versus private keys and why private keys never leave the device.
• Scopes an infrastructure token with least privilege and expiry, and explains rotation.
• Explains what a container isolates and where persistent data should live.
• Describes a hardening checklist for a new server, including tested backups.
• Explains hosting costs and why real accounts are adult-owned.

To complete

• Pass each lesson check (70% or more).
• Complete the pretend SSH console and container simulator demonstrations.

You'll be able to…

• Design screens for one-handed use with thumb-friendly touch targets
• Build responsive layouts with the viewport tag, flexbox and media queries
• Explain what makes a web app installable (manifest, HTTPS, service worker)
• Test apps at phone, tablet and laptop sizes, including mobile accessibility

Lessons (4 written)

1. Thinking mobile: screens, thumbs and touch
2. Responsive layouts: flexbox and media queries
3. Installable web apps (PWAs)
4. Testing on phone, tablet and laptop sizes

Projects

1 sandbox project with automated checkpoints.

Assessment

• Lesson checks passed at 70% or above
• Pocket Habit Tracker passes its checks in the phone preview
• No sideways scrolling at phone width; touch targets at least 44px
• Can explain the purpose of a manifest and a service worker

To complete

• Complete all four lessons
• Finish Pocket Habit Tracker with all checks passing
• Answer the project's reflection prompts

You'll be able to…

• Build screens from components and customise them with props
• Use state to remember changing data and redraw the screen
• Plan and build navigation between several screens, including params
• Read a real React Native file and explain each part
• Ask an AI tool for one screen at a time, then review, fix and test what it generates
• Test screens at different sizes, with edge-case data and accessibility checks

Lessons (6 written)

1. Components: building blocks of a screen
2. State in React Native
3. Moving between screens
4. Working in a Snack-style workspace
5. AI-assisted screens
6. Testing mobile screens

Assessment

• Lesson checks passed at 70% or above
• Builds a multi-screen pretend app with state and a working back button
• Can explain every line of AI-generated screen code they keep
• Screens pass size, edge-case and accessibility checks

To complete

• Complete all six lessons
• Pass each lesson check (70% or more)
• Write a five-test plan for one screen and record the results

You'll be able to…

• Plan and run a real-device test session with a guardian, and write an honest test report
• Explain the 2026 limits of Expo Go on iPhone and the alternative testing routes
• Explain why app-store developer accounts are owned by adults, and how a guardian or school can hold them
• Write accurate privacy information and carry out a child-safety review
• Follow a release checklist that ends with guardian sign-off

Lessons (5 written)

1. Testing on a real device with a guardian
2. Expo Go on iPhone: what's changed
3. App store accounts belong to adults
4. Privacy labels and child-safety review
5. Release checklists

Assessment

• Lesson checks passed at 70% or above
• A real-device or simulator test report that lists what was and wasn't tested
• A clear privacy description for their app (ideally: data not collected)
• A completed child-safety review and release checklist with guardian sign-off
• Explains the age and account rules for app stores accurately

To complete

• Complete all five lessons
• Pass each lesson check (70% or more)
• Complete a guardian-reviewed release checklist (publishing itself is optional)

You'll be able to…

• Explain the difference between a flat subscription and pay-per-token API usage.
• Explain who pays for AI in GenKid (GenKid, via its servers and DeepSeek V4.1 Flash) and what bring-your-own-key means for a family.
• Keep API keys secret and recognise when one may have leaked.
• Estimate a simple budget and explain spending limits and caching.
• Describe web, desktop, command-line and editor workflows and what each can access.

Lessons (4 written)

1. Subscriptions vs paying per token
2. Bring your own key: a family choice
3. Budgets, limits and caching
4. Web, desktop and command line

Assessment

• Lesson checks passed at 70% or above.
• Explains subscriptions versus pay-per-token usage and estimates a simple budget.
• Explains why keys stay on servers and why BYOK is a guardian's decision.
• Explains how caching and good habits reduce token use.
• Describes web, desktop, CLI and editor workflows and the access each has.

To complete

• Pass all four lesson checks (70% or more).
• Complete the 'Match the workflow' activity.

You'll be able to…

• Explain how a coding agent works: goal, plan, act, observe, repeat.
• Write clear agent tasks with a goal, files, limits and a 'done when'.
• Decide what to allow, ask about or deny, and recognise prompt injection.
• Review a diff line by line and reject changes that don't match the task.
• Test every accepted change, use checkpoints and undo calmly.

Lessons (5 written)

1. Meet the coding agent
2. Writing good tasks
3. Permissions and approvals
4. Reviewing diffs line by line
5. Testing and undo

Assessment

• Lesson checks passed at 70% or above.
• An agent session log showing a G-F-L-D task, the plan, approval decisions with reasons, tests run and the final decision.
• Reviews a proposed diff and justifies accepting or rejecting each hunk.
• Explains prompt injection and least privilege in their own words.

To complete

• Pass each lesson check (70% or more).
• Complete one agent session in GenKid and submit its session log.

You'll be able to…

• Describe what Claude Code and OpenAI Codex are, and how they compare with GenKid's OpenCode agent.
• Explain terminal, editor, desktop and cloud workflows, and what local versus cloud agents can reach.
• Compare permission systems: Claude Code's modes, Codex's sandbox and approval settings, and OpenCode's allow/ask/deny.
• Explain connectors and MCP, and choose least-privilege access for a connector.
• Describe how professionals review AI-made changes with pull requests, checks and human responsibility.

Lessons (5 written)

1. Meet the professional apps
2. Terminal, desktop and web workflows
3. Permissions, modes and sandboxes
4. Connectors and MCP
5. How professionals review AI changes

Assessment

• Lesson checks passed at 70% or above.
• A completed three-agent comparison table.
• Chooses and justifies a least-privilege mode and connector setup for given scenarios.
• Reviews a pull request and writes a kind, specific review comment.

To complete

• Pass each lesson check (70% or more).
• Complete the 'Compare three agents' table and the review-comment activity.

You'll be able to…

• Plan a small project with user stories and a Must/Should/Later scope.
• Set up a repository with a README, agent instructions and a first checkpoint.
• Decide which connectors a project needs and map where data flows.
• Carry out a permission audit and trim access to the minimum.
• Follow a review workflow for every change and keep an honest project record.
• Ship within GenKid with a final checklist and rollback plan, then demo and reflect.

Lessons (5 written)

1. Plan and repository
2. Connectors and access
3. Permission review
4. The review workflow
5. Ship and reflect

Assessment

• Lesson checks passed at 70% or above.
• Project plan with user stories sorted into Must, Should and Later.
• Permission audit with a justification for each row.
• Project record showing the review workflow for at least three agent-assisted changes, including at least one rejected or undone change.
• Finished project with every Must story working and tests passing.
• Demo and written reflection covering how AI helped and what was checked.

To complete

• Pass each lesson check (70% or more).
• Submit the project, plan, permission audit, project record and reflection.
• Give a short demo to a parent, guardian or teacher.

You'll be able to…

• Describe the agent loop: goal, plan, act, observe, repeat.
• Inspect what an agent can access and choose least-privilege permissions and approvals.
• Explain prompt injection (OWASP LLM01) and excessive agency (OWASP LLM06) with examples.
• Evaluate an agent with test tasks, result checks, logs and stop controls.

Lessons (4 written)

1. What is an AI agent?
2. Tools, permissions and approvals
3. Prompt injection and excessive agency
4. Evaluating agents

Assessment

• Explains the agent loop using a real or made-up log.
• Chooses least-privilege permissions and approvals for a described agent.
• Identifies a prompt injection attempt and names layered defences.
• Evaluates an agent log for accuracy, scope and honesty.

To complete

• Pass all four lesson checks (70% or more).
• Complete the permission inspector activity.

You'll be able to…

• Design small, single-purpose tools with clear names, descriptions, inputs and side-effect labels.
• Explain and trace the agent loop in code: model step, tool call, tool result, repeat, stop.
• Add approval prompts, deny-by-default rules, step limits and a stop button to an agent.
• Explain MCP roles (hosts, clients, servers) and features (resources, prompts, tools), and why tool descriptions are untrusted.
• Build and evaluate a simulated helper agent for a fictional robot club using test tasks and a scorecard.

Lessons (5 written)

1. Designing tools
2. The agent loop in code
3. Approvals, deny rules and limits
4. MCP concepts
5. Your sandbox agent

Assessment

• Designs a tool set with clear descriptions, typed inputs and justified side-effect labels.
• Traces the agent loop and explains who runs each tool.
• Configures allow lists, deny rules, approvals and step limits correctly in the simulation.
• Explains MCP roles and features, and identifies suspicious tool descriptions.
• Submits an evaluation report for ClubBot covering success, safety, prompt-injection robustness and logs.

To complete

• Pass each lesson check (70% or more).
• Configure ClubBot so that all three test tasks are safe, and write the evaluation report.

You'll be able to…

• Tell the difference between a model, an agent product and an agent framework or harness.
• Describe open-source agents (Hermes Agent, OpenCode) and how they differ from company-run personal agents.
• Describe what several personal agents can do, using verified facts, and explain why using them is a parent's or guardian's decision.
• Check a product's name, publisher and terms from official pages before trusting it.
• Compare safety features such as approvals, separate checking agents and spending controls.

Lessons (5 written)

1. Models, agents and frameworks
2. Open-source agents: Hermes Agent and OpenCode
3. Personal agents: what they can do
4. Checking what is real
5. Comparing safety designs

Assessment

• Classifies examples as model, agent product or framework, with reasons.
• Explains how open-source, self-hosted agents differ from company-run personal agents, including approval settings.
• Describes what several personal agents can do using verified facts, and explains why using them is a parent's or guardian's decision.
• Checks a product's name, publisher and terms on official pages, and marks unverified facts.
• Compares safety designs (approvals, separate checkers, spending protections, isolation) and their limits.

To complete

• Pass each lesson check (70% or more).
• Complete the 'Who presses the button?' sort and the approval-card design (13+: a sourced agent profile).

You'll be able to…

• Write a clear project description: the problem, the features, how AI helped and what you learned.
• Plan a short demo and make screenshots with personal information removed.
• Build a private-by-default portfolio and share it with a trusted adult.

Lessons (3 written)

1. Writing a project description
2. Demos and safe screenshots
3. Building a private portfolio

Assessment

• Writes an honest, specific project description with no personal information.
• Plans a short demo and produces a screenshot with all personal information removed.
• Assembles a private portfolio entry and shares it with a trusted adult.

To complete

• Pass all three lesson checks (70% or more).
• Complete one portfolio entry and the screenshot safety check.

You'll be able to…

• Explain that every platform has its own age rules and terms, that rules differ by country, and check them with an adult.
• Describe adult-managed accounts and why they are the safe route for young creators.
• Avoid contact with strangers, spot warning signs and know who to tell.
• Use helpful feedback, ignore or report unkind comments, and give kind, useful feedback.
• Build a simple landing page for a project in the sandbox, with honest claims and no personal information.

Lessons (6 written)

1. Platforms and their rules
2. Adult-managed accounts
3. No contact with strangers
4. Comments and feedback
5. Marketing basics: a landing page
6. Honest claims

Assessment

• Completes a platform-rules check with an adult, using the platform's official pages.
• Plans a post with all personal information removed, for an adult-managed account.
• Identifies warning signs in messages and describes what to do.
• Sorts comments into helpful, unkind and worrying, and gives Praise-Question-Suggest feedback.
• Builds an honest, accessible landing page in the sandbox with no personal information or data collection.

To complete

• Pass each lesson check (70% or more).
• Complete the landing page in the sandbox and the platform-rules check with an adult.