On your computer Local
Choose this for files and apps already on your computer.
Keep the computer awake and the agent running.
A practical guide. One useful task at a time.
Go beyond
asking questions.
Your AI can make things, work with your apps, and finish tasks while you do something else. Here’s how to start.
Choose a lesson. Read the example. Copy the prompt into your AI and replace anything in [brackets].
What’s an agent?An AI that works toward a result: it reads, uses tools, checks its work, and takes the next step.
Choose where to work
Start with the kind of task you want done. You do not need every tool to begin.
- ChatGPT: ask questions, explain ideas, and draft text.
- Work: ask ChatGPT to complete a task using files and tools.
- Codex: work on a software project, edit its files, and run tests.
Where should it run?
On a remote computer Cloud
Choose this for work that can use uploaded files and connected online tools.
Your laptop can be off if no step needs a local tool.
How to tell: in desktop Work, check Work locally / Cloud. In Codex, look for Local / Worktree / Cloud. Worktree is local, too. Controlling a computer from your phone does not turn it into a cloud task.
A cloud job can still pause for missing information or permission. Labels and features vary by account and app version.
Give a clear request
Ask the AI to interview you first. Build the prompt together before building the product.
“Build me an LMS” (a learning management system) leaves a lot to guess. Spend time describing what you want before asking the agent to build it.
Example · Izzy’s Virtual Classroom A 3D homeschool world: finishing a real book adds it to a virtual bookshelf, unlocks a reward, and gives parents a record of learning.
Start with an interview
Help me write a build prompt for my daughter's learning management system: a playful 3D homeschool classroom with reading, math, science, and a useful parent view. Interview me first, 3–5 questions at a time. Do not start building yet. Ask follow-up questions when my answers are vague. Help me define: - The experience: who uses it, what they do, and how it should feel. - The deliverable: the first complete learning activity, what must work, and how we will test it. - The guardrails: privacy, child safety, budget, and what is out of scope. - Authorized actions: which files and tools you may use, what you may change or install, and whether you may spend money or publish. Then turn my answers into one self-contained implementation prompt. Separate the first version from future ideas, list unresolved assumptions, and let me review the prompt before implementation.
- Answer and refine. Explain the experience you want. Let the agent ask about details you have not considered.
- Review the build prompt. Check the deliverable, guardrails, authorized actions, and what “done” means.
- Then build. Give the reviewed prompt to Codex. Test the complete learning activity before adding more features.
Expand and read the full LMS promptHide the full LMS prompt
This is the implementation prompt for after the interview. Notice the specific learning activity, parent tools, privacy rules, permissions, and completion checks. Adapt the personal details and permissions before using it.
Full classroom build prompt
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.
Scroll inside the prompt to keep reading.
Clear decisions matter more than word count. A complex project deserves a detailed conversation. Save the prompt that works as a playbook you can adapt next time.
Keep your context together
A Project holds the files and instructions an ongoing piece of work needs.
Use a Project for work you will return to. Create one in ChatGPT, add the relevant files, and start related chats inside it.
Example · Deep Space Field Notes Keep observing notes and equipment details together, so you can plan the next clear night without explaining your setup again.
Try it with your project
Using the observing notes and equipment list in this project, suggest three targets for my next clear night. Ask for my location and date if they are missing. Explain why each target suits my equipment.
Add rules you should only have to say once
Put preferences in Project instructions. For a coding project, save them in AGENTS.md at the top of the project folder. That file gives Codex standing instructions.
Example · BullyBearAI Require evidence for claims about a financial app.
AGENTS.md starter
# Working rules - Explain changes in plain language. - Label sample data and uncertain claims. - Never invent customer feedback or test results. - Test changed behavior and report what was not checked. - Finish with what changed, the evidence, and the next step.
Connect your tools
A plugin or connector lets the AI use another app with your permission. Start with the apps that hold your work.
| Connection | What it makes possible |
|---|---|
| Gmail | Find customer emails and prepare replies. |
| Google Drive | Read plans and documents without attaching each one. |
| GitHub | Read issues, review code, and prepare pull requests. |
| AWS Core | Inspect cloud services and help with deployment tasks. AWS sign-in is also required. |
Connect one service first
- Open the Plugins directory. Find the service, select + to add it, and sign in when prompted.
- Read the permission screen. If it shows checkboxes, tick the access you want to grant, then approve.
- In Settings → Plugins (called Apps in some versions), open the connection’s Permissions. Keep Always ask for actions you want to review. Start a new chat to use the plugin.
AWS Core adds AWS tools and guidance. Your AWS sign-in and account permissions determine what those tools can actually do.
Example · Customer feedback check
Find recent customer questions in my connected Gmail and the product plan in Google Drive. Summarize the three biggest gaps between what customers ask for and what we plan to build. Link the sources. Only read; do not send or edit anything.
Why this matters: the AI can work from your actual business information. Reading a message and sending one are separate actions; approve the access and actions you intend.
Save a routine as a skill
A skill is a saved set of steps the AI can follow again. Use one for a task you repeat.
Example · Good Morning and Good Evening Start with a short plan. Finish with a record of what changed and what comes next.
Create your daily skills
Help me create two reusable skills: Good Morning and Good Evening. Ask which calendar, email, chat, GitHub, and document connections to check, and where to save my daily note. Good Morning: check those sources and give me three priorities, today's meetings, and blockers. Good Evening: compare the morning plan with actual progress. Save completed work, open commitments, and tomorrow's first step. Include source links and say when a connection could not be checked. Do not send messages or change my calendar. Test both skills once.
Set it up: choose @skill-creator in ChatGPT, where available, and paste the prompt. In Codex CLI or the IDE, use $skill-creator. Save the skills, then ask: “Run my Good Morning skill.”
A skill remembers how. A schedule decides when. Try the skill yourself before asking it to run automatically.
Build a website with Sites
Sites turns a conversation into a working website, small app, or browser game that you can share with a link.
How to use it: choose @Sites and describe what you want. Ask for a first version, try it, then describe one improvement at a time. Choose the audience before publishing the version you want to share.
Example · Before the Morning Bell A scary escape room: explore an abandoned hospital, find a key, and unlock the exit.
Build a small first version
@Sites Create a short, spooky browser escape game called Before the Morning Bell. Start with one room, one hidden key, and one locked exit. Add a clear goal, readable controls for mouse and touch, and an ending when I escape. Include an optional sound toggle; keep sound off until I turn it on. Save a first version for me to review before publishing. Include brief instructions for trying it.
Try the whole game. Then give specific feedback: “I found the key, but the door stayed locked. Fix that interaction and check the complete escape.”
Put a task on a schedule
A schedule runs a task later or repeats it. Browsing lets that task check current information on websites.
Example · Dumpster pricing watch Once a week, check rival companies’ public offers. Compare the same dumpster size, rental period, and included weight.
How to use it: give the AI the company websites and ask it to browse them once. Check that first result, then ask it to repeat the job at a specific time.
Start a weekly pricing check
Check these dumpster rental companies in [city]: [official website URLs]. Compare [dumpster size], rental days, included weight, base price, and extra fees. Link each source and date the result. Mark unpublished prices “quote required.” Do not contact the companies. Run this once now and save the comparison in [destination]. After I check it, schedule the same task for Mondays at 8 AM in [timezone]. Compare with the last successful result and report changes or failed checks. Confirm the task exists and where I can see its results.
Check the schedule in ChatGPT. A written promise is not a created task. Confirm its time, timezone, and first result. Use cloud-accessible files and tools if you want it to run with your laptop off.
Let an agent handle a longer job
Give the AI one outcome and enough direction to work through several steps. A goal describes the finish line; it is not a guarantee of unlimited runtime.
Example · BullyBearAI An overnight Codex session worked through epic #1090 and produced eight draft pull requests—proposed code changes ready for review.
The run reported 11h 25m of session elapsed time and a separate 2h 46m goal timer. It did not deploy to AWS. The Claude edition adapts the workflow; the original run used Codex.
- Create an epic. This is the overall outcome, such as “Make our weekly customer report trustworthy.” Add small feature issues underneath, each with a clear completion check.
- Label the features. AFK means “away from keyboard”: the AI has enough information and permission to finish. HITL means “human in the loop”: it needs a person’s decision, access, or real customer feedback.
- Launch the ready work. Set the scope, time limit, and allowed actions. Subagents are extra AI workers; give each a separate task and have the lead agent track progress.
- Review in a new chat. Give another agent the code changes and test evidence. Ask it to inspect and check the work before you use it.
Start in Codex with the project open and GitHub access available. Use /goal where supported, including the desktop app, interactive Codex CLI, or IDE extension. In Work on the web, paste the brief directly. Check Local or Cloud before stepping away.
Launch a bounded job
In Codex, work through the AFK-ready features under [repository and epic]. Refresh the issues and project rules first; skip blocked or human-dependent work. Use up to two subagents on independent tasks, with separate branches. For each feature, implement it, run the relevant tests, update documentation, and open a draft pull request. Save progress after each feature. Stop after [time limit], at [usage limit], or when no ready work remains. Report any limit you cannot measure. Do not merge or deploy. Finish with PR links, test evidence, dependencies, and what needs a person.
Hand the result to a fresh reviewer
A second chat gets a clean look at the work. Include the epic, pull requests, and the original completion checks. If deployment is part of the review, name the exact test environment.
Review and validate the work
Review BullyBearAI epic #1090 and PRs #1128, #1129, #1130, #1134, #1135, #1136, #1139, and #1140. Fetch current changes and dependencies; do not rely only on the author's summary. Check the code and rerun tests. Fix problems on the affected PR branch and push the updates. Recheck after every fix. Deploy and test sequentially only in [authorized AWS test account, region, and environment]. Stop if that target is unspecified. Record the deployed commit and results for each PR. Do not merge or touch production, broker access, or trading controls. Finish with the review order and remaining blockers.
Before you leave: check that the agent can reach the files and tools, knows when to stop, and has somewhere to save progress. Long jobs can still stop for limits, questions, or missing access.
Before you call it done
Open it. Try it. Check the evidence.
Read the document, play the game, inspect the task, or test the change. Ask what was not checked. Save the instructions that worked so your next task starts further along.