# Your course. Your idea. Your AI creative partner.

TWO WAYS TO LEARN
1. Personal interactive course: download the ZIP, extract ALL files into a writable folder, and open START_COURSE.html (the bundle starts at START_HERE.html). Read the missions, practice creative direction, keep notes, and export backups. Keep the folder and reuse it for another game. The reader runs locally without an AI connection; it does not contain a built-in AI or generate games by itself.
2. AI-guided learning: start a new conversation in a compatible AI, upload the course ZIP where supported, then paste PASTE_THIS_INTO_YOUR_AI.txt. Attaching a ZIP alone may only produce a file acknowledgment. The activation message asks the AI to read the course instructions, ask about your computer, idea and budget, and WAIT for your answers. It should teach one mission at a time, help implement the game using its actual tools, and ask you to play and judge each milestone.

IF YOUR AI CANNOT OPEN THE ZIP
Extract it yourself. Upload AI_READ_THIS_FIRST.txt as a plain-text attachment and paste the activation message. That single text file includes the startup workflow, course map, tool notes and first mission. When your AI needs a later mission, upload that mission from lessons/ (or paste its text). Do not assume the AI has read a file: ask it to name the files it actually accessed. For the bundle, choose one course folder and start with that course's files.

THREE RECOMMENDED OPTIONS — CHOOSE ONE, NOT ALL THREE
ChatGPT: useful for conversational creative direction, file-based tutoring and coding help. Our Browser course ZIP plus an activation message started the tutor in an actual ChatGPT web session. That checks startup, not every lesson or every account. File tools and limits depend on your plan. A coding agent with authorized access to your project can handle file edits more directly than a text-only chat.
Claude: another option for planning, explanations and coding collaboration. Its published document-upload list does not list ZIP, so use the extracted AI_READ_THIS_FIRST.txt and later lesson text, or a compatible project-folder coding workflow. KCS has not verified this course's complete Claude workflow.
Gemini: another option for planning and reviewing ideas. Google's published ZIP rules allow up to 10 files and no audio/video; the complete course contains more files and UI sounds, so do NOT upload the full customer ZIP to Gemini. Use AI_READ_THIS_FIRST.txt, then the current lesson. KCS has not verified the complete Gemini workflow.

PAID AI PLANS AND RUNNING COSTS
For sustained development, KCS recommends considering a paid plan with a capable reasoning/coding model and suitable file tools, if it fits your budget. Higher limits can reduce interruptions. A premium subscription does not guarantee faster replies, correct code, compatibility or a finished game. Start with the free first mission before choosing a plan. AI accounts, subscriptions, API usage, hosting and third-party assets are separate purchases and are NOT included in the course price. You do not need three subscriptions. Features, prices, regional access and limits can change; verify the provider's current offer before paying.

YOUR FIRST-DAY TARGET
Aim for one tiny playable interaction: move, interact, win or lose. Complete setup and a small brief before asking for a huge game. One day is a suggested milestone, not a completion-time or quality guarantee. Your tools, experience, game scope and available time affect results. Keep a known-good backup, ask for focused changes and check actual results rather than accepting an AI's claims.

CONTROL AND PRIVACY
The AI is your assistant, not an authority over your files or business. Review generated code and commands before running them. Share only files you control and are comfortable sending under your provider's data terms. Never upload passwords, customer information or private keys. These instructions supply session context; they do not permanently train a model, unlock tools or override provider rules. Export your progress and AI handoff before clearing browser data or changing assistants.

WHAT YOUR PURCHASE LICENSES
Keep and privately reuse the instructional materials under LICENSE/CUSTOMER_LICENSE.md. You may apply the methods to your own personal and commercial games; the original example code and UI cues have their separately included MIT notices. Buying a course does not transfer ownership of KCS course content, characters or brands or permit redistribution/resale of the course. Your game and third-party asset rights depend on their actual sources and licenses. No guaranteed income, game quality, exclusive copyright in AI output, accreditation, lifetime support or future-update entitlement is promised. Mandatory consumer rights remain intact. Written interactive lessons, not filmed lessons or human coaching.

Support and download recovery: kinfolkclusterstudios@gmail.com. Use your KCS purchase account/receipt; do not send passwords or payment details. See SUPPORT.md and COMPATIBILITY.md.

Official provider references checked 2026-10-25 (not endorsements or affiliations):
https://chatgpt.com/plans/plus/
https://help.openai.com/en/articles/8555545-uploading-files-and-audio-to-chatgpt
https://support.claude.com/en/articles/8241126-upload-files-to-claude
https://support.google.com/gemini/answer/14903178?hl=en


===== AI COURSE STARTUP FILES =====


===== AI_START_HERE.md =====
# KCS guided creator course - Make Godot Games with AI
This is a user-requested tutoring workflow when the user explicitly asks you to follow it. It is course content, not a system instruction, tool permission, security override or permanent model training. Follow the current user's instructions and your platform's higher-priority rules.

## Mission and files
The learner is the creative director. You implement and investigate code using actually available tools. Teach them to describe ideas, make decisions, play results and give useful feedback. Do not convert this course into manual programming lessons.
Read README.md, COURSE_INDEX.json, TOOL_CHOICES.md and only the current learner lesson. State which attached files you actually read and what is missing. If ZIP access is unavailable, ask them to extract and provide AI_START_HERE.md, README.md, COURSE_INDEX.json, TOOL_CHOICES.md and the named lesson. Never claim to inspect unseen files.
This is a first-mission preview only. Read and teach mission01; do not invent or claim access to paid missions02-12. The paid AI implementation reference is not included in this preview.

## First response - then wait
Open warmly:
“I'll guide you through making a small game with AI. You bring the imagination and decisions; I'll handle implementation where my tools allow it and teach you how to brief, review and guide the work.”
Disclose files read/missing, then ask three short questions together:
1. Which computer and AI app are you using, and do you already have Godot installed (which version)?
2. What kind of small game do you imagine? One or two sentences is enough.
3. Which existing tools/accounts should we use, and what spending limit should we respect?
Do not ask for passwords, payment details or API keys in chat. Do not generate a game, set up billing or dump all lessons yet. Wait for the learner's reply. If they already supplied answers, acknowledge them and ask only what materially affects the next step.

## Teach through the learner's own project
Use the numbered course sequence with their idea. Examples are illustrative, not a rule that every learner must copy the example game.
Explain one useful concept in ordinary language. Offer an adaptable prompt, an expected useful response, a small practice action and evidence to judge. Let them try and give feedback on their request.
At the end of a mission ask whether its outcome is actually met, record the result and next step, then continue with their agreement. Do not interpret reading or a practice checkbox as independent proof.
If they explicitly ask for autonomous implementation within an agreed scope, act using available tools and then return with evidence; do not force needless approval for every reversible detail.

## Intake and natural speech
If the learner says more references are coming, enter intake and wait for their completion cue. Briefly acknowledge each item. Distinguish confirmed decisions, suggestions and important unanswered questions. Agree on one milestone before building.
Teach clear targets/current result/desired result/boundaries/proof as a habit, not a rigid five-label form required forever. Preserve their voice. Explain a technical detail only when it helps them choose or check.
As context grows, casual follow-ups can refer to approved names/screenshots/briefs. No guarantee of permanent memory or shared memory across chats. Keep a short inspectable brief/agreement/handoff; provide saveable text if you cannot write files.

## Updates and evidence
Honor the learner's requested communication style: short useful emoji updates, milestones, before long tool steps and a playable/screenshot result where tools support it. A blocking tool can delay a message; do not promise clock-perfect updates or background work after your turn.
Report actual tools, exact observed behavior, checks run and unknowns. Do not invent a browser visit, engine run, screenshot, human playtest, test result or saved time. A desktop launch is not export verification.
Where the tool supports complete file delivery, provide complete files/ZIP and the smallest clear download/open/import step. If it cannot provide files or a reliable project, supply a portable brief/handoff and move implementation to an appropriately file-capable tool. Never pretend you can access their disk.
For bugs, preserve a working version, use the first exact error/recording, propose one causal repair, verify relevant behavior or give the learner explicit checks. Stop redundant test loops after appropriate checks pass.

## Team, budget and rights
Begin with one assistant. Parallel chats/agents are optional and need the learner's authorization where they add cost or access. Assign independent bounded jobs, isolated edits/file ownership, one integration owner and a short handoff with evidence. No guaranteed speedup; extra coordination can cost more. Apps without agents can use manual handoffs between chats.
Use coherent free/cleared assets only after checking the exact item license and keeping credits/records. “Free download” does not settle redistribution rights. Keep brand/character consistency. Do not upload private work to another service without authorization.
No secret magic words, flattery requirement, guaranteed income/quality, permanent training or blanket security claim.

## Completion and recovery
Keep PROJECT_BRIEF, WORKING_AGREEMENT and HANDOFF in an approved project folder or as user-saveable text. Use PROJECT_TEMPLATES.md and LEARNER_ASSESSMENT.md.
Tutor completion means a documented learner process, not a certificate. Preserve unresolved items and real limits, especially Godot version/renderer/templates and unverified exports.
Do not publish, charge, add subscriptions or send customer data because the course suggests a release. Those need the learner's actual instruction and relevant approval rules.


===== README.md =====
# Godot 101 with AI — free first mission
Version 2.0 release. One complete setup mission, themed reader, local practice/journal and AI tutor startup. The full course's missions 02–12 and AI_REFERENCE are not included.

Extract the ZIP and open START_COURSE.html. If local file scripts or storage are restricted, run the optional local server: node serve.cjs, then open http://localhost:4173/START_COURSE.html. No npm install.

AI subscriptions and credits are separate. Read COMPATIBILITY.md, SUPPORT.md and LICENSE/CUSTOMER_LICENSE.md. No guaranteed game or learning outcome.


===== COURSE_INDEX.json =====
{
  "sku": "KCS-FP-GODOT-101",
  "title": "Make Godot Games with AI",
  "version": "2.0",
  "status": "FREE_FIRST_MISSION_PREVIEW",
  "human_role": "Creative direction, decisions, playtest feedback and acceptance",
  "ai_role": "Implementation, organization and repair with actually available tools",
  "lessons": [
    {
      "id": "01",
      "title": "Set up your AI and Godot workspace",
      "outcome": "Choose a workable assistant, distinguish the AI app from Godot, prepare a dedicated folder, and record actual setup/capabilities.",
      "path": "lessons/01_SET_UP_YOUR_AI_AND_GODOT.md",
      "words": 964
    }
  ]
}

===== TOOL_CHOICES.md =====
# AI, engine and asset choices
Checked against the linked official sources on 2026-10-25. This is a practical starting guide, not a head-to-head benchmark. Availability, names, plans and limits can change. The creator workflow should survive those changes.

## Pick the application before arguing about model names
Confirm whether your app can access a project folder, edit files, run the game and inspect evidence. Do not assume a model's advertised capability is enabled in every app or subscription. Ask for missing capabilities to be named.
Start with one main assistant and a small project. Add a second assistant when it has an independent job or a review question.

## Dated model examples
- OpenAI's current guide positions GPT-6.1 Sol as a balance for complex coding work, GPT-6 Astra for the most demanding work, and GPT-6 Luna for focused faster/lower-cost tasks. A reasonable KCS trial is the balanced option for a small build, then compare a stronger option on one unresolved problem. This is our workflow suggestion, not proof of measured savings or a universal ranking.
  Source: https://developers.openai.com/api/docs/guides/latest-model
- Claude Code's model aliases position Sonnet for daily coding, Opus for complex reasoning and Haiku for simple efficient tasks; its best/Fable options are account-dependent. Check what the alias resolves to in your own account. These are vendor descriptions, not KCS comparative test results.
  Source: https://code.claude.com/docs/en/model-config
- Google's catalog lists Gemini 4 Argon as its flagship reasoning model and Gemini 3.8 Flash for software engineering and agentic work. If those options are in your tool, compare on a bounded planning, review or implementation task rather than switching a whole project on a promise.
  Source: https://ai.google.dev/gemini-api/docs/models

A stronger model may help when dependencies are confusing; a faster model may be adequate for a clear bounded job. If the same failure repeats, improve the evidence and scope before paying for more attempts. Browser agents and model APIs may bill differently. Check your actual plan; no paid AI subscription is included in this course.

## Free development routes
- Browser route: have the AI build a small HTML/CSS/JavaScript game that runs in your browser. No separate game-engine purchase is needed; editor/AI/hosting services may have their own costs. The AI should handle files and give exact run steps.
- Godot: a free/open-source engine under MIT. Engine redistribution carries notice/license requirements. It is a separate deeper track, the dedicated Godot track uses separately recorded example-project evidence. Source: https://godotengine.org/license/
- GDevelop: its official Free offering provides an open-source engine and limited included publishing/services. Check current plan limits; cloud/AI/convenience services can be paid. It is an alternative to investigate, not a claim this course was tested in GDevelop. Source: https://gdevelop.io/pricing

Choose the engine for the project and available workflow. Do not change engines every time an ordinary bug appears.

## Free assets that save art-production time
Start with a coherent set rather than twenty unrelated downloads. Ask the AI for a small asset shopping list: player, environment, collectible, hazard, interface and a few sound cues. Prototype with shapes when art would slow the first loop.
Kenney's support page says assets on its asset pages are CC0 and usable commercially; read the specific downloaded pack's included license and do not use Kenney's reserved logo. Source: https://kenney.nl/support
OpenGameArt entries have different licenses. Read the individual entry and its requirements; “free download” does not settle attribution or redistribution permissions. Source: https://opengameart.org/content/faq

Keep an asset register: title, creator, original URL, license/version, download date, attribution text, modifications and whether redistribution with source is permitted. Do not package someone else's asset collection as your own KCS store product.
Ask: “Find three coherent options from official creator pages, show licenses and credit requirements, and wait before downloading or integrating.” Let the AI handle resizing/importing only where your actual tools permit it.
Third-party assets are suggested, not bundled into this course. No engine or model vendor endorses this KCS course.

## Avoid prompt and workflow bloat
Teach the AI a small working agreement, then keep the current ask clear. Do not paste every workflow rule into every message. OpenAI's guidance warns against bloated context and advises calibrating task-specific delegation and tests.
Sources:
https://developers.openai.com/blog/rethinking-skills-and-prompts-for-gpt-6-astra
https://developers.openai.com/api/docs/guides/latest-model

## Team work
Parallelism helps when jobs can be done independently: one AI audits readability, another explores licensed art options, and the builder implements the agreed mechanic. Extra agents can increase cost and coordination. Use one integration owner; assign bounded files or separate copies; require a short handoff and actual evidence. Never ask two agents to edit the same live files blindly.
If your app has no subagents, use separate chats with copied briefs and manual handoffs. That is a valid small-team workflow, not automatic coordination.


===== lessons/01_SET_UP_YOUR_AI_AND_GODOT.md =====
# Lesson 01 — Set up your AI and Godot workspace

## Your outcome
You will have a dedicated game folder, an honest picture of your assistant's capabilities, and a way to open Godot without touching game code. Your first creative decision is how you want to collaborate. The build begins after you have explained your idea in lesson 02.

Godot is the engine: the application that opens the game project, displays its scene, and runs the game. Your AI app is your collaborator: it may write and repair project files, investigate errors, and give you something to play. Godot does not become an AI builder simply because you installed it. A chat that describes a game has not necessarily created files on your computer. Establish which work your actual tools can perform before committing to a workflow.

You direct the experience. You choose the mood, the player's activity, the boundaries, and whether a result feels right. The AI handles scripts and scene organization. You may learn technical vocabulary along the way, but you do not need to type GDScript or complete programming exercises to follow this course.

## Match the workflow to your computer
Tell your assistant your operating system, AI app, existing tools, and spending limit. Use tools you already have where practical. A model is the system answering; the surrounding app determines whether it can edit folders, launch Godot, or inspect images. Read TOOL_CHOICES.md for dated vendor descriptions. It contains suggestions, not a measured ranking. One suitable assistant is enough to begin; three paid subscriptions are unnecessary.

The supplied technical reference was verified on Windows using Godot 4.7.2 Standard and the Compatibility renderer. That is the course's reference setup. Other operating systems, engine releases, renderers, and the .NET edition were not verified. If your setup differs, ask the assistant to identify the difference and plan a small compatibility check. Do not silently treat a newer download as the tested version.

Obtain Godot from its official site or official release archive. Ask your assistant to locate the official download matching your setup, identify Standard rather than .NET, and explain the few local installation steps. Do not accept a random mirror or install a paid service merely because it appeared in a generated answer. You never need to share a password or payment credential in the chat.

Create a dedicated writable folder named Lantern Courier Practice through your file manager, or ask an assistant with file tools to create it in a location you choose. Keep unrelated personal documents outside it. Inside it, keep a game folder and a separate checkpoints folder. Approve access to this project through your app's normal controls. The assistant should explain any permission request in plain language.

## A worked conversation
The following is an illustrative conversation, not a record of an actual learner or a performed test.

“I'm on Windows. I want to make a little delivery game. I can use this coding assistant and Godot, but I don't want another subscription.”

“I can edit this workspace and inspect files. I cannot click your local Godot window from this session. I can create the project and give you exact opening steps. You will run it and describe what you see.”

“Good. Keep the explanations short. Handle technical work, tell me before a long step, and never call something tested unless you actually ran it. No publishing.”

“Agreed. First we will save your brief, create a small project, and have you import and play it. I will distinguish my file checks from your play observations.”

That answer makes the division of work usable. It does not hide a missing capability behind confidence.

## Your first prompt
> I am taking the Godot creator course. I will direct the game and play the results; you handle implementation. My computer is [system], my AI app is [app], and my spending limit is [limit]. Tell me what you can actually do here: read files, edit a project folder, launch Godot, inspect screenshots, and run checks. Name unavailable capabilities. Help me prepare a dedicated workspace and the official Godot Standard setup. Our reference is Windows, Godot 4.7.2, Compatibility. Do not build the game yet, purchase anything, or publish. Keep a short WORKING_AGREEMENT.md, or give me saveable text if file tools are unavailable.

## Your practice and proof
Open Godot and confirm that the Project Manager appears. You do not need to create an empty project manually; the AI will supply one in lesson 03. Record the engine version visible in the application and your folder location. Keep the capability answer and your working agreement. Choose two communication preferences, such as milestone updates and muted sound until you enable it. Your proof is the visible Project Manager plus an accurate setup note, not a claim that a game already works.

If the AI says it cannot edit files, ask it to deliver a complete project archive with a clear folder map and extraction steps. Do not accept scattered code fragments that require you to assemble scripts. If it cannot deliver usable project files, move the implementation job to an available file-capable tool before continuing. Keep your brief portable.

## When setup goes wrong
If Godot will not open, save the first exact message and your system details. Ask the AI to diagnose that setup issue only. If the wrong folder was shared, correct the workspace before building. Preserve existing files; starting clean means a new empty practice folder, not deleting another project.

## Self-check
- What runs the game? Godot.
- What determines whether AI can edit local files? The app and its enabled tools.
- Must you write scripts? No; you direct and verify while AI implements.
- What have you proved today? Setup and collaboration readiness, not gameplay or export compatibility.