I want to build a virual classroom website for my 3 year old daughter. we've started homeschool. Build “Izzy’s Virtual Classroom” — A 3D Homeschool Learning World You are being given this project as a one-shot autonomous engineering task. Your job is not merely to scaffold a repository, create a mockup, write a design document, or produce disconnected prototypes. Build the most complete, polished, runnable version of the product that you can within the available environment. Act as the product designer, senior full-stack engineer, game developer, curriculum-systems architect, UX designer, and QA engineer. Do not wait for clarification unless something is literally impossible to infer. Make strong, sensible product decisions yourself. The primary evaluation criteria are: How much of the vision you successfully implement. How polished and cohesive the finished experience feels. Whether the core gameplay loop actually works. Whether the application feels like a real product rather than a developer demo. Code quality, architecture, maintainability, performance, and tests. How intelligently you handle parts of the vision that cannot reasonably be completed in one pass. PRODUCT VISION Build a personalized 3D homeschool world initially for a child named Izzy. Izzy turns four on January 1. Despite her age, she is already reading independently at approximately a third-grade level. Her parents want to challenge her intellectually without forcing every subject into a conventional age-grade box. The system should recognize that a child may simultaneously have very different ability levels in: reading mathematics science writing reasoning vocabulary life skills creativity The application should therefore adapt by domain, not assign one global “grade level.” The experience should feel like a genuine video game that happens to provide a rigorous education. It should NOT feel like: a homeschool spreadsheet with cartoons a generic LMS a collection of worksheets a dashboard with “gamification” a preschool app full of giant primary-colored buttons a thin Three.js tech demo The central fantasy is: Izzy has her own living 3D school. She walks through it, learns inside it, reads real books, completes lessons and real-world homeschool activities, earns things through genuine progress, watches her school physically grow as she learns, and can proudly show her family everything she has accomplished. The emotional target is this moment: Izzy runs to the computer because she wants to put the new book she finished onto her virtual bookshelf, sees that she has now read 100 books, receives a new pet dragon, and then excitedly gives Grandma a tour of everything she learned that month. Build toward that feeling. DESIGN DIRECTION The visual direction should combine: A personalized dream school with: a beautiful, playful, believable elementary-learning environment. Think: warm cozy tactile inviting magical without being excessively fantasy-themed expressive lighting high-quality materials playful environmental storytelling little visual surprises rooms that look like places a child would actually want to explore Do NOT imitate copyrighted worlds or characters. Avoid making it feel like Hogwarts, Minecraft, Roblox, Fortnite, Duolingo, etc. It should have its own identity. The world can gradually become more fantastical as Izzy progresses. For example, an initially grounded science room might eventually contain: a working planetarium a giant aquarium a dinosaur exhibit a glowing crystal collection a telescope observatory a greenhouse Learning should literally transform the environment. PRIMARY USER EXPERIENCES There are three primary modes. 1. CHILD MODE This is Izzy’s experience. It should be a true explorable 3D game environment. She should be able to: walk around explore rooms interact with objects approach teachers inspect her bookshelf begin lessons see accomplishments unlock objects interact with rewards see her school physically change over time Controls should be simple enough for a young child. Support keyboard + mouse initially. Structure controls so controller support can be added cleanly. Avoid interaction patterns requiring precision mouse use. Large interaction ranges and obvious affordances are preferable. 2. PARENT MODE The parent-facing experience is primarily for Izzy’s mother. This needs to be extremely useful and should not be treated as an afterthought. Parents need a serious homeschool recordkeeping and curriculum tool underneath the game. The parent should be able to record things like: “Izzy read two chapters of Charlotte’s Web this morning. She summarized what happened without help and correctly explained why Wilbur was scared. Later we baked bread and she measured 2 cups of flour and 1 tablespoon of yeast.” The system should interpret this into proposed educational evidence such as: Reading Reading comprehension Oral narration Vocabulary Measurement Mathematics Science Life skills The parent should then be able to review/edit/save it. For this implementation, if a live AI model is unavailable, implement a believable local rules/heuristics system and a clean abstraction for replacing it with an AI service later. Do not make the whole feature dependent on having an API key. Parent workflow should emphasize: type one thing → system does the organization rather than forcing the parent to complete a giant form. 3. FAMILY SHOWCASE Create the beginnings of a mode where Izzy can show someone what she has accomplished. This may be called something like: My Learning Museum My School Izzy’s World Showcase A family member should eventually be able to see things such as: books completed projects science discoveries artwork rooms unlocked milestones photos favorite accomplishments For this first implementation, build a useful local showcase even if remote sharing is not yet implemented. CORE GAME LOOP The most important flow is: Izzy enters her school. She explores the 3D classroom. She enters or approaches the library area. She interacts with a virtual teacher. She records or completes progress on a real book. That book visibly appears on her physical 3D bookshelf. Her reading collection/progress changes. She earns a meaningful reward. Her world changes in some visible way. Parent mode shows the activity and learning evidence. This loop must work. If you have to choose between implementing 20 half-working systems and making this loop excellent, prioritize this loop. WORLD STRUCTURE The school should be designed to expand over time. Initial or future areas include: Central Classroom Library Math Room Science Lab Art Studio Garden / Greenhouse Observatory Learning Museum Reading nook Trophy / accomplishment area Not all rooms need to be fully implemented immediately. However, build the architecture so rooms are modular and unlockable. A good first playable environment may contain: main classroom library zone science corner locked doors or visible future spaces The environment should communicate: “There is much more to discover.” WORLD PROGRESSION Learning should alter the world. Examples: Read 10 books: bookshelf expands Read 25 books: reading nook unlocks Read 50 books: larger library opens Read 100 books: special celebration + pet dragon Study plants: greenhouse gains plants Complete a space unit: observatory unlocks objects Study dinosaurs: museum gains a fossil or dinosaur display Do a nature walk: collected items can populate a nature exhibit Complete artwork: artwork can appear on classroom walls The school itself should become a persistent visual record of learning. Implement at least several examples of this system. READING SYSTEM Reading is especially important. Every real book Izzy reads should be capable of becoming a persistent object in her virtual library. Each book record should support fields such as: title author cover image if available date started date completed pages or chapters child rating parent notes comprehension notes favorite part optional drawing/work sample independent / assisted reading tags reading difficulty metadata if known The child-facing experience should NOT obsess over grade labels. Izzy should largely be free to read books she loves. Internally, parents may record or review difficulty and ability evidence. The 3D shelf should visually fill as books are completed. Make this visually satisfying. If external book APIs are unavailable, include seeded sample books and build an API abstraction for future metadata lookup. CURRICULUM The application should actually teach. Primary academic focus: Reading Mathematics Science Secondary domains may include: writing art nature life skills problem solving vocabulary Underneath the playful experience, curriculum should map to established educational frameworks where appropriate. Examples: Mathematics Use concepts compatible with Common Core-style progression. Science Use concepts compatible with NGSS-style progression. Literacy Use evidence-based literacy concepts and age-independent reading comprehension skills where appropriate. Do not expose standards codes to the child. Example: PARENT VIEW: Number & Operations Demonstrates addition within 20 independently. CHILD VIEW: Rocket Rescue Complete! 🚀 Create a curriculum data structure supporting: domains strands skills prerequisites mastery state evidence difficulty attempts parent observations lesson relationships Seed enough curriculum content to demonstrate the system meaningfully. ADAPTIVE LEARNING Do NOT give Izzy one global grade level. Maintain independent capability estimates per subject or skill domain. For example: Reading comprehension: advanced Phonics: mastered foundational concepts Addition: developing Measurement: emerging Scientific observation: strong The system should attempt to present work just beyond demonstrated mastery. A child who struggles should receive: hints visual explanations manipulatives simpler intermediate problems alternate explanation another attempt Avoid punitive failure. Do not use: harsh red Xs lost points humiliation “you failed” punishment for mistakes Use language like: “Almost. Let’s try another way.” However: Do NOT fake mastery. The parent system should accurately distinguish: introduced developing proficient mastered Create the foundations for a lightweight adaptive engine. A deterministic implementation is acceptable for this first version. FORMATIVE ASSESSMENT Assessment should often be disguised as play. Do not constantly announce: TEST TIME Examples: A reading teacher asks Izzy what happened in the story. A math robot needs help distributing 14 moon rocks. A science teacher asks which object will sink. Use results as evidence of skill. Build at least one functioning example. The system should preserve evidence that can support statements like: “Izzy independently answered inference questions about this text.” rather than merely saying: “Izzy was exposed to reading.” VIRTUAL TEACHERS Include recurring subject teachers/NPCs. Suggested starting cast: Professor Hoot Reading and storytelling. Personality: warm, curious, enthusiastic about books. Digit Math. Could be a small friendly robot. Personality: playful, precise, loves puzzles and counting. Nova Science. Could be an adventurous animal, creature, or young scientist. Personality: curious, experimental, constantly asking “why?” You may improve these names/designs if you have a stronger cohesive art direction. Teachers should: have recognizable locations greet the child provide lesson interactions give encouragement present learning objectives through stories/tasks adapt difficulty remember basic progress Do not build unrestricted AI chat for the child. Teacher interactions should initially be: bounded educational lesson-aware predictable parent-visible Design the architecture so conversational AI can later augment structured interactions. VOICE-READY ARCHITECTURE Eventually, voice may become a major interface. Potential future interaction: Teacher: “What do you think will happen if we put this in water?” Izzy: “I think it sinks because it’s heavy.” The system could assess reasoning and continue. Do not make voice recognition mandatory for this version. But architect teacher interactions so text input can later be replaced or supplemented by: speech-to-text text-to-speech pronunciation analysis oral narration conversational tutoring If browser-native speech support can be safely and cleanly implemented as an optional enhancement, you may add it. Always provide a non-voice fallback. REWARDS Rewards should celebrate genuine learning. Examples: pet companions classroom furniture plants art outfits trophies bookshelf expansions room expansions observatory equipment science objects museum exhibits environmental effects Avoid manipulative mobile-game mechanics. NO: loot boxes monetization paid currencies artificial scarcity punishment for missing a day anxiety-producing streak loss endless notification mechanics Streaks may be displayed positively if useful but should never punish absence. Prefer: Knowledge → Collections → World Growth over generic XP grinding. PET SYSTEM Implement at least the foundation of collectible companions. A pet dragon should exist as a high-profile reward, even if only as a milestone demonstration. Example: 100 books read → special dragon companion unlocked. For development/demo purposes, include a debug/demo way to preview milestone rewards without manually entering 100 books. Do not undermine the actual progression system—this should simply aid testing. REAL-WORLD HOMESCHOOL ACTIVITIES Parents should be able to record activities outside the computer. Examples: baking nature walks gardening museum trips science experiments handwriting painting building something counting money helping cook observing wildlife These should contribute to the learning portfolio. Activities should support: date narrative subjects skills photos/work samples parent observations child reflection standards alignment demonstrated mastery/evidence duration if desired The UI should make these easy to enter. PARENT DASHBOARD Create a polished parent experience. At minimum include: TODAY recent activities lessons books progress suggested follow-up PROGRESS Break down domains such as: Reading Math Science Writing Creativity Life Skills CURRICULUM Show: mastered proficient developing introduced suggested next concepts PORTFOLIO Show: photos projects work samples book records assessments observations REPORTS Create at least one usable report view. Eventually support: weekly monthly semester annual grandparent-friendly showcase For this version, generate a polished learning summary using locally stored information. NATURAL LANGUAGE ACTIVITY ENTRY This is a major feature. Parent enters: “Izzy and I baked muffins. She counted 12 cups, measured the flour herself, read several steps of the recipe, and asked why the muffins get bigger in the oven.” The system should infer or propose: Math Counting Measurement Reading Sequencing Science Chemical/physical change curiosity Life skills The parent reviews the suggestions before saving. If no LLM is configured, implement a local parser/classifier good enough to demonstrate the workflow. Architect it behind a service interface such as: ActivityInterpretationService so a real AI provider can later replace it cleanly. MULTI-CHILD ARCHITECTURE Although Izzy is the initial child, this must be built as a multi-child household system. Her younger sister Georgia should eventually have her own profile. Architecture: Household → Parent accounts → Child profiles → Independent curriculum state → Independent worlds → Independent books → Independent portfolios → Independent rewards The children may eventually share family spaces, but progress must remain separable. Seed Izzy as the initial profile. Georgia can exist as an optional/inactive future profile. AVATAR SYSTEM Eventually, parents should be able to upload a photo selected by the child and use it as inspiration for a game avatar. For this version: Build avatar customization architecture. Provide a starter Izzy avatar. Allow customization such as hair, clothing, skin tone, accessories, etc. Provide a parent-controlled photo upload area if practical. Do NOT implement biometric identification or face recognition. Do NOT automatically upload children's photos to third-party services. Keep any future image-to-avatar pipeline clearly separated behind a safe service boundary. If image transformation is unavailable, do not fake it. Instead make the UX clearly show how it would fit later. VISUAL QUALITY This application should look intentional. Do not ship a gray-box scene with cubes and default materials and call it complete. Spend time on: lighting materials environmental composition UI typography camera feel interaction feedback transitions animations sound hooks environmental storytelling Use a cohesive art direction. Stylized realism is preferable to attempting photorealism. Think polished indie game, not enterprise dashboard. 3D TECHNICAL DIRECTION Prefer a web-first architecture. Recommended stack: React TypeScript Vite or appropriate modern equivalent Three.js React Three Fiber Drei where helpful Zustand or similarly lightweight state management if useful Use physics only where it adds value. Do not add unnecessary complexity. Target: desktop browser first keyboard/mouse architecture compatible with later controller support eventual tablet compatibility Keep rendering performance reasonable. Use: instancing where appropriate optimized meshes compressed assets where practical sensible shadow settings lazy loading LOD only if necessary BLENDER Use Blender as an asset creation pipeline if it is available and useful. You are authorized to: inspect whether Blender is installed use Blender scripting generate models procedurally create/modularize classroom assets export GLB/glTF assets build low-poly/stylized environmental pieces If installing Blender is permitted and reasonable in the execution environment, you may install it. Do NOT block the project on Blender. If Blender is unavailable: create high-quality procedural geometry or temporary assets in Three.js preserve an asset pipeline that allows Blender models to replace them later If you use Blender, save source .blend files or generation scripts in a clear assets/source directory. SOUND Add tasteful game audio architecture. Useful examples: footsteps UI feedback page/book sound unlock sound gentle classroom ambience teacher greeting cues Do not use copyrighted music. Do not make audio annoying or constant. Provide volume/mute controls. If actual sound assets are unavailable, create the architecture and use legally safe generated/simple audio where possible. DATA ARCHITECTURE The project should use a real persistent data model. For a local-first first version, acceptable approaches include: SQLite IndexedDB local backend database another sensible embedded/local datastore Prefer a solution that can migrate cleanly to production. Potential entities: Household Parent Child Avatar Book ReadingSession Activity Evidence Subject Skill CurriculumStandard Lesson LessonAttempt Mastery Reward UnlockedItem Room PortfolioItem Report TeacherInteraction Do not make everything a single giant JSON blob. Use sensible relationships and types. PRIVACY AND CHILD SAFETY This application stores information about young children. Design accordingly. Requirements: parent is the administrative authority avoid unnecessary personal information no ad tech no trackers no social network no public child profiles no unrestricted web browsing for the child no child-facing external links no manipulative engagement mechanics parent can inspect educational interactions photo uploads remain controlled by the parent do not use face recognition do not silently send child data to third parties structure external AI integrations as explicit optional services A local-first architecture is strongly preferred for this prototype. DEMO CONTENT Seed enough data for the product to feel alive immediately. Include examples such as: several completed books a partially completed book several math skills several science skills a baking homeschool activity a nature activity a reading assessment progress toward an unlock at least one unlocked cosmetic/world reward Do not make Izzy's fictional educational history look authoritative. Clearly treat seeded information as demo/sample data. Provide an easy way to reset demo state. VERTICAL SLICE The highest-priority deliverable is a complete vertical slice. It must include this sequence: CHILD Start application. Select/enter Izzy’s world. Spawn inside a polished 3D classroom. Walk around. See a recognizable library area. Approach Professor Hoot or equivalent reading teacher. Interact. Choose/add/finish a book. Answer at least one small comprehension/activity interaction. Complete the interaction. Watch the book appear physically on the bookshelf. See reading progress change. Receive a reward or unlock. See the environment react. PARENT Enter parent mode. See the reading activity. See evidence from the interaction. Enter a natural-language homeschool activity. Review automatically proposed subject/skill classifications. Save it. See progress/portfolio update. Open a learning report summarizing recent progress. This entire flow should be functional. GAME FEEL Pay attention to feel. Implement small details like: smooth movement camera damping hover/interact cues object highlighting satisfying unlock animations environmental animations NPC idle motion bookshelf changes animated doors if appropriate particles used sparingly polished menus child-friendly readable typography obvious interact prompts Avoid overloading the screen with HUD elements. The world itself should communicate progress whenever possible. CHILD UX Remember: Izzy is almost four. Even though she reads far beyond her age, motor/UI expectations should remain developmentally appropriate. That means: large interaction targets minimal nested menus visual cues few simultaneous choices forgiving controls little required typing optional reading aloud later clear back/home navigation no complex settings exposed in child mode Advanced reading ability does not mean adult UI dexterity. PARENT UX Parent mode may be much denser. Optimize it for: speed clarity evidence planning records Parents should be able to understand: “What does she know?” “What is she working on?” “What did we do?” “What should we try next?” “What evidence do we have?” within a few minutes. ENGINEERING QUALITY Use: strict TypeScript clear components/modules sensible separation between game, learning domain, and persistence automated tests formatting/linting error handling accessible non-3D parent UI deterministic seeded data clear environment configuration Do not scatter magic constants throughout the code. Create appropriate abstractions for: persistence curriculum lesson engine adaptive progression rewards AI activity interpretation asset loading teacher interactions Avoid premature microservices. This should be easy to run locally. TESTING Test critical logic. At minimum test areas such as: mastery/progression transitions reward unlocking book completion activity classification multi-child data separation persistence curriculum recommendations Where practical, add browser/end-to-end tests for the main vertical slice. Actually run tests. Fix failures. QUALITY ASSURANCE Before considering the task complete: run the app inspect it visually click through major flows verify 3D controls test book completion verify bookshelf update verify reward unlock test parent entry test report generation test persistence after reload check console for errors check responsive parent UI run automated tests run lint/type checking fix obvious visual defects Do not claim a feature works because code exists. Verify it. PROJECT DOCUMENTATION Include a useful README. It should contain: what the product is architecture setup run commands test commands major features implemented major directories data model overview curriculum architecture 3D asset pipeline Blender workflow if used how to replace local activity interpretation with a real LLM future voice architecture known limitations recommended next development priorities Also create a concise architecture/design document if helpful. AUTONOMY This is deliberately a one-shot test. Do not stop after scaffolding to ask what to do next. Do not ask me to pick: libraries colors schemas folder names state management database implementation art direction details component architecture Decide. If one approach fails, try another. If a dependency is unavailable, create a fallback. If you cannot implement the entire vision, prioritize a cohesive, impressive vertical slice and leave the repository substantially better than a prototype. Use the available tools and execution environment aggressively. Inspect your own work as you go. PRIORITY ORDER If time/capacity forces tradeoffs, prioritize in this order: Runnable application. High-quality 3D classroom. Good player controls/interactions. Library and physical bookshelf. Book completion loop. Virtual reading teacher. Reward/world-growth system. Parent activity logging. Natural-language interpretation. Evidence/portfolio model. Curriculum and mastery model. Parent progress dashboard. Learning report. Math/science lesson examples. Additional rooms. Avatar improvements. Audio polish. Additional world content. Quality of the core experience is more valuable than breadth. SUCCESS CRITERIA When you finish, I should be able to clone/open the project and reasonably say: “This is the beginning of a real 3D homeschool game, not a mockup.” Izzy should be able to: walk through her classroom, interact with a teacher, finish a book activity, see that book join her growing physical library, and receive something exciting for learning. Her mother should be able to: record homeschool experiences naturally, preserve detailed evidence, see meaningful academic progress, and produce a useful learning summary. And the architecture should make it believable that this could grow for years with Izzy and later Georgia. FINAL EXECUTION INSTRUCTIONS Start by inspecting the current environment/repository. If the repository is empty, initialize it appropriately. Then implement. Do not spend your response describing what you intend to build instead of building it. Create files, install dependencies where appropriate, run commands, generate assets, test the system, inspect results, and iterate. Use the entire available work session productively. At the end, provide a concise handoff containing: What you built. What works end-to-end. Architecture and important implementation decisions. Exact commands to run it. Tests/checks performed and their results. Anything that remains incomplete. The highest-value next improvements. The code and working application are the deliverable. Begin.