Kingy AI beginner course
Build real apps, tools, and websites without being a traditional developer.
A practical Kingy AI course for creators, founders, marketers, students, and non-technical builders.
These buttons scroll to the first lesson and prompt builder on this page.
Source and accuracy note
Built Around Durable Codex Workflows
This course focuses on durable beginner skills: defining tasks, giving context, setting constraints, asking Codex to plan, reviewing changes, debugging issues, and testing before publishing.
Last updated: May 25, 2026
Preview and manually test Custom HTML blocks in WordPress before publishing.
Test prompts, buttons, calculators, quizzes, and layouts in your own browser before using them live.
Codex product details can change. Always check official OpenAI documentation for current features, settings, plan access, and product surfaces.
Start here
Recommended firstHow to Use Codex as a Beginner: Your First 30 Minutes
You do not need to know how to code yet. You do not need to know GitHub, terminal commands, pull requests, or JavaScript to begin. You need a clear process: describe the goal, set limits, ask Codex to plan, review what changed, and test the result.
Understand what Codex is
Learn the difference between asking AI a question and managing an AI coding agent.
Pick your path
Choose whether you are a founder, creator, marketer, WordPress user, student, or beginner developer.
Generate your first safe prompt
Use the prompt builder to describe the goal, context, constraints, and definition of done.
Build one tiny practice project
Start with a landing page, calculator, prompt library, quiz, or checklist before touching anything high-risk.
Review, test, and improve
Ask Codex what changed, what could break, and what you should test before publishing.
This course is not about pretending Codex is magic. It is about learning how to direct it, constrain it, review it, and safely ship small useful projects.
These actions scroll to the next course step.
Course progress
Track your beginner Codex progress.
Use these simple checks as you move through the page. Progress is saved only in this browser. No login required. It is meant to help you track your learning path, not grade you.
No account, analytics, backend, or tracking is used for this progress card.
Start with Lesson 0 and generate your first prompt.
Course navigation
What you will build
Small projects that teach the real workflow.
The goal is not to build a giant app on day one. The goal is to practice giving Codex clear instructions, reviewing the result, and testing before publishing.
Landing page
A simple page with sections, copy, buttons, and mobile layout.
WordPress calculator
A pasteable Custom HTML tool with inputs, results, and working buttons.
Prompt library
Reusable prompt cards with categories and copy buttons.
Quiz
A beginner-friendly quiz with answers, explanations, score, and reset.
Mini AI tool directory
A no-backend directory with cards, filters, and plain-English descriptions.
Sponsor ROI calculator
A business-friendly calculator for creators, marketers, and sponsors.
First AGENTS.md file
A reusable instruction manual for Codex inside a project folder.
Review checklist
A repeatable way to check buttons, mobile layout, copy behavior, and risk.
Interactive path selector
Choose your beginner path.
Pick the option that sounds most like you. The recommendation updates instantly.
Recommended path
Founder starter path
Module 3: Prompting Codex
A one-page product validation landing page.
Give Codex the audience, offer, page goal, and what must be avoided.
Keep the first project small enough to review every section yourself.
Course roadmap
OpenAI Codex Course Roadmap for Beginners
This roadmap shows what each module helps you do, what lessons are inside, what to practice, and how to know you are ready to move forward. Open a module when you want the details.
Do not try to master every tool first. Learn the workflow, then build one small thing.
Module 0What Codex Is
Starter
A plain-English introduction to AI coding agents and what beginners should expect.
Outcome: You can explain what Codex is, what it can help with, and why human review still matters.
What Codex Is
Lessons inside
- What an AI coding agent is
- What Codex can help with
- What Codex is not
- Why small projects are safer
Practice exercise
Write one small project idea and list what Codex should avoid changing.
Copy/paste Codex prompt
Do not write code yet. I am a beginner. Explain what this project or page is in plain English, then suggest one small safe first project I can build. Tell me what you would avoid changing and what I should test.
You are ready for the next module when…
You can describe Codex as a tool you direct, constrain, review, and test.
Module 1Setup for Beginners
Starter
Learn how to prepare a practice folder, organize project notes, and start with low-risk work.
Outcome: You can create a safe practice space and give Codex a clear project brief.
Setup for Beginners
Lessons inside
- Practice folders vs live pages
- What to save before editing
- Writing a project brief
- Keeping private information out
Practice exercise
Create a beginner project brief with the page goal, audience, constraints, and done criteria.
Copy/paste Codex prompt
Help me set up a safe beginner practice project. Do not write code yet. Ask me for the project goal, where it will be used, what should not change, and how I will test it. Then turn my answers into a simple project brief.
You are ready for the next module when…
You have a practice project idea and a short brief Codex can understand.
Module 2Computer Basics for Codex Users
Beginner
Understand files, folders, browsers, text editors, and the basic words Codex may use.
Outcome: You can understand common project words without feeling blocked by jargon.
Computer Basics for Codex Users
Lessons inside
- Files and folders
- HTML, CSS, and JavaScript in plain English
- Local vs live website
- What the browser console is for
Practice exercise
Ask Codex to explain a file, folder, or HTML block in non-technical language.
Copy/paste Codex prompt
Explain this project structure in plain English for a total beginner. Define any technical words you use. Tell me which files or sections are most important and which ones I should avoid changing until I understand them.
You are ready for the next module when…
You can tell the difference between structure, styling, and interaction.
Module 3Prompting Codex
Beginner
Write prompts that include the goal, audience, constraints, examples, and review request.
Outcome: You can write a clear Codex prompt using goal, context, constraints, and done criteria.
Prompting Codex
Lessons inside
- The four-part prompt formula
- How to describe context
- How to set constraints
- How to define done
- How to ask for a plan first
Practice exercise
Rewrite “build me an app” into a specific prompt for a tiny beginner project.
Copy/paste Codex prompt
I want to build [small project] for [audience]. Before writing code, create a beginner-friendly plan. Use this structure: Goal, Context, Constraints, Done when. Ask clarifying questions if anything is unclear.
You are ready for the next module when…
You can write a prompt that tells Codex what to build, where it will be used, what to avoid, and how to test it.
Module 4Your First Codex Projects
Beginner
Start with useful projects small enough to understand and test in one sitting.
Outcome: You can choose a realistic first project and keep the scope small.
Your First Codex Projects
Lessons inside
- Choosing a tiny project
- Landing page basics
- Calculator basics
- Prompt library basics
- Quiz/checklist basics
Practice exercise
Pick one first project and write what the user should click, enter, copy, or learn.
Copy/paste Codex prompt
Help me choose one small beginner Codex project. My role is [role]. I want something [useful for business / just practice]. Recommend one project, explain why it is safe, and give me the first prompt to build it.
You are ready for the next module when…
You have chosen one project small enough to test in 60-120 minutes.
Module 5Debugging with Codex
Builder
Describe what broke, share the exact behavior, and ask Codex to diagnose before changing code.
Outcome: You can explain a bug clearly enough for Codex to diagnose it without guessing wildly.
Debugging with Codex
Lessons inside
- Expected vs actual behavior
- Reproduction steps
- Reading error messages
- Asking for the smallest safe fix
Practice exercise
Describe a broken button using expected behavior, actual behavior, steps, and constraints.
Copy/paste Codex prompt
Something is broken. Expected behavior: [what should happen]. Actual behavior: [what happens instead]. Steps to reproduce: [steps]. Please diagnose the likely cause before editing, then make the smallest safe fix and tell me exactly what to test.
You are ready for the next module when…
You can describe a bug without only saying “it does not work.”
Module 6Reviewing Codex Work
Builder
Learn how to ask what changed, what to test, and what could break.
Outcome: You can review Codex changes before publishing and know what to test.
Reviewing Codex Work
Lessons inside
- What changed
- What could be affected
- How to ask for risk notes
- Desktop and mobile testing
- When to stop and ask questions
Practice exercise
Ask Codex to summarize a change in plain English and create a test checklist.
Copy/paste Codex prompt
Review the changes in beginner-friendly language. Explain what changed, why it changed, what existing features might be affected, what I should test on desktop and mobile, and any risks I should know before publishing.
You are ready for the next module when…
You can ask for a change summary, risk summary, and test checklist before publishing.
Module 7Codex for WordPress
Builder
Use Codex to create pasteable Custom HTML blocks that avoid extra plugins and dependencies.
Outcome: You can ask Codex for a self-contained WordPress Custom HTML block and test it safely.
Codex for WordPress
Lessons inside
- What Custom HTML blocks are
- Scoped CSS
- Why no API keys in front-end code
- Testing buttons after paste
- Mobile WordPress preview checks
Practice exercise
Draft a WordPress prompt for one calculator, quiz, comparison table, or checklist.
Copy/paste Codex prompt
Build a self-contained WordPress Custom HTML block for [tool]. Use only HTML, scoped CSS, and vanilla JavaScript. No React, no external libraries, no backend, no API calls, and no API keys. Make all buttons work and tell me how to test it after pasting.
You are ready for the next module when…
You can explain why scoped CSS, no external dependencies, and button testing matter in WordPress.
Module 8GitHub and Cloud Workflows for Beginners
Optional
Learn the vocabulary first, then decide if cloud workflows belong in your project.
Outcome: You can understand common GitHub terms without needing to use them immediately.
GitHub and Cloud Workflows for Beginners
Lessons inside
- Repo and branch in plain English
- Commit and diff
- Pull request as a review step
- When cloud workflows are helpful
- When beginners can skip GitHub
Practice exercise
Ask Codex to explain repo, branch, commit, pull request, and diff using a simple analogy.
Copy/paste Codex prompt
Explain the GitHub or cloud workflow for this project in plain English. Define repo, branch, commit, pull request, and diff. Tell me whether I need this workflow now or whether a simpler beginner approach is enough.
You are ready for the next module when…
You can decide whether GitHub is useful for your project or unnecessary for your first build.
Module 9Capstone Project
Capstone
Plan, build, review, test, and publish one simple real-world project from start to finish.
Outcome: You can complete one small project using the full Codex workflow.
Capstone Project
Lessons inside
- Choosing the capstone
- Writing the project brief
- Asking Codex to plan
- Building and reviewing
- Testing and publishing safely
Practice exercise
Plan and build one publishable beginner project, such as a WordPress calculator, landing page, prompt library, or quiz.
Copy/paste Codex prompt
Help me plan my beginner capstone project. I want to build [project] for [audience]. First create a plan, constraints, file/section list, testing checklist, and definition of done. Do not write code until I approve the plan.
You are ready to finish when…
You can explain what Codex changed, test the project yourself, and publish only after the important interactions work.
Lesson 0
Recommended firstLesson 0: What Is OpenAI Codex?
This first lesson is for total beginners. You do not need to know code yet. You only need a calm process for telling Codex what you want, what to avoid, and how you will check the result.
Lesson promise
By the end of this lesson, you will understand what Codex is, what it is useful for, what it is not, and why beginners should start with small projects they can personally review and test.
Plain-English explanation
Codex is an AI coding agent that can help plan, write, edit, debug, and review code when you give it a clear task and enough context. It can help with pages, tools, small apps, bug fixes, and code review, but it still needs human direction.
Product details change over time. For current Codex features, access, settings, and product surfaces, check official OpenAI documentation before relying on exact product-specific steps.
The beginner mental model
Codex is less like a magic button and more like a junior technical teammate. It can be very useful, but it needs a clear task, constraints, review, and testing.
What beginners usually misunderstand
- Codex is not a guarantee that everything is correct.
- “Build me an app” is usually too vague.
- Small projects are better than giant first projects.
- Planning first reduces mistakes.
- Reviewing changes matters.
- Testing buttons and mobile layout matters.
- API keys should not be pasted into front-end code.
The four-part beginner prompt formula
What do you want Codex to do?
Where will this be used, who is it for, and what does Codex need to know?
What should Codex avoid changing, adding, or assuming?
How will you know the work is finished and safe to test?
Copyable Lesson 0 prompt
Do not write code yet. I am a beginner learning to use Codex. First, explain the project folder or page I am working on in plain English. Then suggest one small safe first project I can build. Tell me what files or sections you would touch, what you would avoid changing, and how I should test the result.
Mini exercise
Before you ask Codex to build anything, write one plain-English answer for each prompt below.
Example: a calculator, landing page, quiz, checklist, or prompt library.
Example: WordPress Custom HTML block, local HTML file, or an existing website.
Example: do not redesign the page, remove sections, use external libraries, or add API keys.
Example: buttons work, results appear, mobile layout is readable, and there are no console errors.
Mini quiz
1. What is the safest first Codex project?
2. Why should Codex plan before coding?
3. What does “done when” mean?
Lesson 0 checklist
Who this course is for
Built for practical beginners.
You do not need to speak like a developer to start. You need a clear goal, a careful process, and a way to check the work before publishing.
Non-technical founders
Turn rough product ideas into simple prototypes, landing pages, and internal tools.
Creators and YouTubers
Build audience tools, resource hubs, content calculators, and lead magnets.
Marketers
Create campaign pages, interactive offers, comparison tools, and prompt libraries.
WordPress users
Publish self-contained tools with Custom HTML blocks and fewer moving parts.
Students
Learn the workflow behind building small apps without getting buried in jargon.
Beginner developers
Use Codex as a planning, review, debugging, and practice partner.
What you will learn
The beginner workflow for AI-native building.
- What Codex is
- How to prompt Codex
- How to ask Codex to plan first
- How to build simple tools
- How to debug with Codex
- How to review changes safely
- How to use Codex with WordPress Custom HTML blocks
- How to think like an AI-native builder
Interactive prompt builder
Recommended firstBest Codex Prompts for Beginners
Strong Codex prompts usually explain the goal, context, constraints, and what done means. This builder turns plain-English answers into safe prompt versions you can paste into Codex.
Fill in what you know. If you are unsure, choose the closest option. The builder will create a plan-first prompt, a build prompt, and a review/testing prompt.
What do you want Codex to do?
Where will this be used, and what should Codex know?
What should Codex avoid changing or adding?
How will you know the work is complete?
This creates prompts you can paste into Codex.
Your generated prompts will appear below.
Start with a backup. Ask Codex to inspect and plan before editing. Review all changes before publishing.
What to paste into Codex next: start with the Plan-first version. After you approve the plan, use the Build version. After Codex changes anything, use the Review/testing version.
Click Generate My Codex Prompts to create beginner-friendly Codex prompts.
Plan-first version
Click Generate My Codex Prompts to create this version.
Build version
Click Generate My Codex Prompts to create this version.
Review/testing version
Click Generate My Codex Prompts to create this version.
WordPress calculator
Goal: Build a calculator for a Custom HTML block. Constraints: no external libraries, scoped CSS, mobile-friendly, and working buttons.
Debug broken button
Goal: Diagnose why a button does nothing. Constraints: explain the likely cause first, then make the smallest safe fix.
Improve mobile layout
Goal: Make an existing page easier to use on phones. Constraints: preserve working features and avoid overlapping text or tiny buttons.
Plan first trainer
Before Codex Codes, Make It Plan
For complex or unclear tasks, beginners should often ask Codex to inspect, plan, and explain before editing files. A strong plan-first prompt helps Codex understand the goal, the project context, what not to change, and what a good result looks like.
Optional advanced Open example weak prompts and stronger rewrites
“Make my website better.”
Why it is weak: “Better” could mean faster, prettier, clearer, more accessible, or more profitable. Codex needs a target.
Do not write code yet. First inspect the project and give me a plan. I want to improve my website, but I need help deciding the safest first changes. Please review the page structure, copy clarity, mobile layout, buttons, and obvious usability issues. Do not change the design, remove sections, add external libraries, or rewrite everything. Give me: - The top 5 improvements you recommend - Why each one matters - Which files or sections you would change - What I should approve before you edit anything
“Build me an app.”
Why it is weak: It skips the audience, features, platform, limits, and first version scope.
Do not write code yet. First inspect the project and give me a plan. I want to build a simple app for [audience] that helps them [main outcome]. Please propose a beginner-friendly first version with only the essential features. Do not add a backend, database, login system, payment flow, or external libraries unless you explain why they are needed. Give me: - A version-one feature list - What should be left for later - The simplest technical approach - What files you would create or change - What I should test when it is done
“Fix this.”
Why it is weak: Codex needs to know what is broken, what should happen, and how to avoid random changes.
Do not write code yet. First inspect the project and give me a plan. Something is broken on [page/file/feature]. Expected behavior: [describe what should happen] Actual behavior: [describe what happens instead] Please diagnose the likely cause before editing code. Do not make broad refactors or change unrelated features. Give me: - The likely cause - The smallest safe fix - What file or section you would change - How I can test that the issue is fixed
“Make this page prettier.”
Why it is weak: “Prettier” is subjective. Codex needs the style, constraints, and what must keep working.
Do not write code yet. First inspect the project and give me a plan. I want this page to feel more polished, modern, readable, and trustworthy. Please focus on spacing, typography, contrast, card layout, mobile readability, and button clarity. Do not remove content, change the core structure, break existing buttons, or add external libraries. Give me: - The design issues you see - A simple improvement plan - What you would change first - How I should test desktop and mobile after edits
“Add AI to my site.”
Why it is weak: It may require APIs, privacy decisions, costs, and data handling. Codex should plan before touching anything.
Do not write code yet. First inspect the project and give me a plan. I want to explore adding an AI-related feature to my site, but I need a safe beginner-friendly recommendation first. Please suggest options that do not require private API keys or user data unless you clearly explain the tradeoffs. Do not add API calls, tracking, external scripts, or backend logic without approval. Give me: - 3 possible AI-related features - Which option is safest for a beginner - What data or keys each option would require - What privacy or cost risks I should understand - What you recommend building first
Rewrite your own vague idea into a safer plan-first prompt.
Use this when your idea is still fuzzy and Codex should inspect or plan before editing.
Your stronger plan-first prompt will appear below.
Enter a vague idea, then click Create a Plan-First Prompt.
Beginner mistake guide
The 15 Mistakes Beginners Make With Codex
Most beginner Codex problems do not come from bad ideas. They come from vague requests, missing context, skipped review, or trying to build too much at once.
Small, clear, tested projects beat giant vague requests.
Showing 15 mistakes
Optional advanced Open the 15 mistake cards
Asking Codex to build too much at once.
Why it happens: Big ideas feel exciting, so beginners ask for the full app immediately.
Why it is risky: Large requests are harder to review, test, and understand.
Better habit: Ask for the smallest useful version first.
Do not build the full idea yet. Help me reduce this into the smallest useful first version I can understand and test in one sitting. List what to build now, what to leave for later, and what I should test.
Starting with production code instead of a practice project.
Why it happens: Beginners want to improve the live thing right away.
Why it is risky: A mistake can break a real page, tool, or business workflow.
Better habit: Practice on a draft, backup, or small copy first.
Before editing anything important, help me create a safe practice version of this task. Tell me what to back up, what to copy, what to test in draft mode, and what should not be touched yet.
Not asking Codex to plan first.
Why it happens: The fastest path looks like asking Codex to start coding.
Why it is risky: Codex may solve the wrong problem or touch the wrong files.
Better habit: Require a plan before edits.
Do not write code yet. First inspect the project and give me a beginner-friendly plan. Explain what you would change, what you would avoid, what could break, and what I should approve before you edit.
Forgetting to explain the audience.
Why it happens: The audience feels obvious to the person with the idea.
Why it is risky: The copy, layout, and feature choices may miss the real user.
Better habit: Tell Codex who the project is for.
Before planning, ask me who this is for. Then tailor the copy, layout, examples, and feature choices to that audience. If the audience is unclear, do not guess.
Not telling Codex where the code will be used.
Why it happens: Beginners ask for a tool without naming WordPress, a local file, or another environment.
Why it is risky: Code that works one place may fail somewhere else.
Better habit: State the publishing environment.
This will be used in [WordPress Custom HTML block / local HTML file / existing website / other]. Please plan and build for that environment, and explain any compatibility risks before coding.
Not setting constraints.
Why it happens: Beginners assume Codex knows what is allowed.
Why it is risky: Codex may add complexity, dependencies, or unrelated changes.
Better habit: Name the limits up front.
Use these constraints: [list constraints]. Do not add external libraries, backend logic, API calls, API keys, tracking, or broad rewrites unless I approve. Keep the solution as simple as possible.
Letting Codex add external libraries for a simple WordPress block.
Why it happens: Libraries can seem like an easy shortcut.
Why it is risky: They may fail to load, conflict with plugins, or make pasting harder.
Better habit: Use vanilla JavaScript for simple blocks.
Rebuild this as a self-contained WordPress Custom HTML block using only HTML, scoped CSS, and vanilla JavaScript. Do not use external libraries or CDNs. Explain any tradeoffs.
Putting API keys in front-end code.
Why it happens: Beginners may not realize visitors can view front-end code.
Why it is risky: Private keys can be exposed and abused.
Better habit: Keep private keys out of public pages.
Check this idea or code for API key risk. Do not put private API keys in front-end HTML, CSS, JavaScript, screenshots, or public pages. If secure server-side logic is needed, explain that clearly and suggest a safer beginner alternative.
Not reviewing what changed.
Why it happens: Beginners may trust the result because it looks complete.
Why it is risky: Unrelated changes or hidden bugs can slip in.
Better habit: Ask for a plain-English change review.
Review the changes in beginner-friendly language. Explain what changed, why it changed, what existing features could be affected, what I should test, and any risks or assumptions.
Not testing buttons.
Why it happens: A button can look finished even when it does nothing.
Why it is risky: The main interaction may fail for visitors.
Better habit: Click every button before publishing.
Create a button testing checklist for this page. Include every button, expected behavior, what should happen on click, reset behavior, copy behavior if any, and what errors to look for.
Not checking mobile layout.
Why it happens: Beginners often test only on the desktop screen in front of them.
Why it is risky: Text, cards, and buttons may break on phones.
Better habit: Test the small screen before publishing.
Review this page for mobile layout issues. Check text size, spacing, button tap targets, card stacking, horizontal overflow, and overlapping content. Suggest focused fixes without redesigning the whole page.
Not saving a backup.
Why it happens: Backups feel like an extra step when momentum is high.
Why it is risky: You may not have an easy way back if something breaks.
Better habit: Save a copy before edits.
Before editing, tell me exactly what backup I should save for this project or page. Then confirm which file or block will be changed and what I should keep untouched.
Saying “fix this” without expected behavior.
Why it happens: The problem feels obvious when you are looking at it.
Why it is risky: Codex may guess the wrong fix.
Better habit: Describe expected and actual behavior.
Something is broken. Expected behavior: [what should happen]. Actual behavior: [what happens instead]. Steps to reproduce: [what I clicked or entered]. Please diagnose before editing and make the smallest safe fix.
Assuming a pretty page means the logic works.
Why it happens: Visual polish is easier to see than hidden logic.
Why it is risky: Calculations, filters, quizzes, and copy buttons can still be broken.
Better habit: Test the actual workflow.
Do a logic and interaction review, not just a design review. Test calculations, filters, quiz answers, copy buttons, reset buttons, empty states, and unusual inputs. Tell me what works and what needs fixing.
Skipping the final review prompt.
Why it happens: Once something looks done, it is tempting to publish.
Why it is risky: You may miss broken interactions, mobile issues, or privacy problems.
Better habit: Run one last review before publishing.
Before I publish, do a final beginner-friendly review. Check whether the project matches the goal, buttons work, mobile layout is readable, no private data or API keys are exposed, and I have a clear manual testing checklist.
First project lab
First Project Lab: Build Something Small With Codex
This is your first hands-on assignment. Pick one beginner track, ask Codex to plan first, build a tiny version, then review and test it before you publish or paste anything live.
Your first project should be small enough to understand, test, and explain. Do not start with a full SaaS app, payment system, login system, or production database.
Landing Page
Recommended first prompt: Use the plan-first prompt for the Landing Page track.
What to test: Headings, buttons, links, mobile spacing, and whether the page clearly explains the offer.
Ask Codex after the first version: Review the page for clarity, mobile layout, broken links, and any risky changes before publishing.
Optional advanced Open full project track details and prompts
Landing Page
Outcome: A simple one-page website section.
What you learn: Page structure, clear copy, CTA buttons, sections, and mobile layout.
What Codex should build: A hero, short proof section, offer section, FAQ, and CTA.
What to avoid: Do not add payments, accounts, analytics, or external libraries.
Open Landing Page prompts and checklist
Plan-first prompt
Do not write code yet. I want to build a simple landing page section for [audience] about [offer/topic]. First give me a beginner-friendly plan with the sections, CTA, mobile layout approach, what you would avoid changing, and what I should test.
Build prompt
Build the approved landing page section using beginner-friendly HTML, scoped CSS, and vanilla JavaScript only if needed. Include a clear headline, supporting copy, CTA button, proof points, FAQ, and mobile-friendly layout. Do not use external libraries.
Test/review prompt
Review the landing page like a strict beginner-friendly QA tester. Check the headline clarity, CTA, links, mobile layout, contrast, spacing, and any console errors. Tell me what changed, what could break, and what I should test before publishing.
Manual testing checklist
- Read the page top to bottom on desktop.
- Click every button and link.
- Check the page on mobile width.
- Confirm text does not overlap.
- Ask whether the CTA is obvious.
WordPress Calculator
Outcome: A pasteable calculator with inputs, results, reset, and copy button.
What you learn: Form inputs, simple calculations, validation, result states, reset behavior, and copy buttons.
What Codex should build: One self-contained WordPress Custom HTML block with scoped CSS and vanilla JavaScript.
What to avoid: Do not use API keys, external libraries, databases, tracking, or unscoped CSS.
Open WordPress Calculator prompts and checklist
Plan-first prompt
Do not write code yet. I want to build a WordPress Custom HTML calculator for [audience]. Inputs should include [inputs]. Results should show [result]. First plan the fields, calculation logic, button behavior, scoped CSS wrapper, mobile layout, and testing checklist.
Build prompt
Build the approved calculator as one self-contained WordPress Custom HTML block. Use HTML, scoped CSS under one unique wrapper ID, and vanilla JavaScript. Include inputs, calculate button, result area, reset button, copy result button, helpful validation, and mobile-friendly layout.
Test/review prompt
Review this calculator before I paste it into WordPress. Check every input, calculate button, reset button, copy button, empty-field behavior, mobile layout, scoped CSS, and console errors. Explain any risks in plain English.
Manual testing checklist
- Try normal numbers.
- Try blank fields.
- Click calculate, reset, and copy.
- Paste into a draft WordPress page first.
- Test on phone width before publishing.
Prompt Library
Outcome: A searchable set of copyable prompts.
What you learn: Cards, categories, search, filtering, copy buttons, and content organization.
What Codex should build: A static prompt library with editable prompt cards and reliable copy buttons.
What to avoid: Do not add login, database storage, API calls, or external dependencies.
Open Prompt Library prompts and checklist
Plan-first prompt
Do not write code yet. I want to build a simple prompt library for [audience]. First plan the categories, card fields, search behavior, copy button behavior, mobile layout, and how I can edit the prompts manually later.
Build prompt
Build the approved prompt library using HTML, scoped CSS, and vanilla JavaScript. Include searchable prompt cards, category filters, prompt titles, when-to-use notes, copy buttons, and a mobile-friendly layout. Keep the prompts easy for me to edit manually.
Test/review prompt
Review this prompt library. Test search, filters, copy buttons, mobile card layout, keyboard access, and empty search results. Explain what changed, what I should manually test, and whether any code could conflict with WordPress.
Manual testing checklist
- Search for a prompt title.
- Try every category filter.
- Copy at least three prompts.
- Check long prompt text on mobile.
- Confirm prompts are easy to edit.
Quiz
Outcome: A simple multiple-choice quiz with explanations.
What you learn: Questions, answer buttons, scoring, feedback messages, reset behavior, and accessible interactions.
What Codex should build: A small quiz with 5 questions, 3 answers each, explanations, score, and reset button.
What to avoid: Do not add accounts, saved grades, databases, or complex learning management features.
Open Quiz prompts and checklist
Plan-first prompt
Do not write code yet. I want to build a beginner quiz about [topic] for [audience]. First plan 5 questions, answer choices, explanations, scoring, reset behavior, accessibility, and mobile layout before writing code.
Build prompt
Build the approved quiz using HTML, scoped CSS, and vanilla JavaScript. Include 5 multiple-choice questions, 3 answer options per question, one correct answer, a supportive explanation after each answer, visible score, and reset button.
Test/review prompt
Review this quiz like a strict QA tester. Check each answer, explanation, score update, reset button, keyboard access, mobile layout, and console errors. Tell me what to test before publishing.
Manual testing checklist
- Answer every question once.
- Check correct and incorrect explanations.
- Confirm the score is accurate.
- Click reset and try again.
- Test on mobile and with keyboard tabbing.
These buttons scroll to project ideas and the WordPress-safe checklist.
Beginner project library
Codex Project Ideas for Beginners
Use these ideas after you understand the basics. Start small, ask Codex to plan first, and choose a project you can test in one sitting.
Showing 10 projects
Optional advanced Open the full project idea library
Personal landing page
Who it is for: Creators, founders, students, and anyone who needs a simple online intro.
What you learn: Page structure, clear copy, sections, buttons, and mobile layout.
What to ask Codex: Ask for a self-contained landing page plan before it writes code.
Do not write code yet. First give me a plan for a simple personal landing page. Audience: [who should visit the page] Goal: [what action they should take] Sections needed: hero, about, proof, offer, contact CTA. Use beginner-friendly HTML, scoped CSS, and vanilla JavaScript only if needed. Make it mobile-friendly and tell me what to test.
WordPress calculator
Who it is for: WordPress users, marketers, and founders who want a practical site tool.
What you learn: Inputs, calculations, result boxes, validation, and Custom HTML block constraints.
What to ask Codex: Ask for one self-contained calculator with scoped CSS and working buttons.
Build a single self-contained WordPress Custom HTML calculator. Before coding, explain the plan. Use one wrapper ID, scoped CSS, and vanilla JavaScript. Calculator idea: [describe the calculator] Inputs: [list inputs] Result: [describe output] No external libraries, no API calls, no backend. Done when the button works, results display, mobile layout is readable, and there are no console errors.
Prompt library
Who it is for: Creators, marketers, students, and teams who reuse instructions often.
What you learn: Cards, categories, copy buttons, search, and content organization.
What to ask Codex: Ask Codex to create a searchable prompt library with copyable prompts.
Plan and build a beginner-friendly prompt library. It should include prompt cards, simple categories, and copy buttons. Use only HTML, scoped CSS, and vanilla JavaScript. No backend, database, tracking, or external libraries. After building it, explain how I should test search, filters, copy buttons, and mobile layout.
AI tool directory
Who it is for: Founders, marketers, and creators who curate tools for an audience.
What you learn: Directory cards, tags, filters, search, and editorial descriptions.
What to ask Codex: Ask for a no-backend directory that can be edited manually.
Create a self-contained AI tool directory for [audience]. Before coding, plan the card fields, filters, and mobile layout. Include tool name, category, best for, short description, and link placeholder. Use static sample data that I can edit manually. No database, backend, API calls, or external libraries. Tell me how to test search and filtering.
Simple quiz
Who it is for: Students, creators, educators, and course builders.
What you learn: Multiple-choice logic, explanations, scores, and reset buttons.
What to ask Codex: Ask for a small quiz with supportive explanations after answers.
Build a simple multiple-choice quiz about [topic]. Include 5 questions, 3 options each, one correct answer, a supportive explanation after each answer, a visible score, and a reset button. Use only HTML, scoped CSS, and vanilla JavaScript. Make it mobile-friendly and explain what I should test.
Comparison table
Who it is for: Marketers, founders, WordPress users, and affiliate-style pages.
What you learn: Tables, responsive layouts, feature comparisons, and CTAs.
What to ask Codex: Ask for a mobile-friendly comparison table that stacks cleanly on phones.
Create a mobile-friendly comparison table for [products/options]. Before coding, propose the columns and explain how the table will work on mobile. Include: name, best for, key features, limitation, and CTA placeholder. Use scoped CSS and no external libraries. Done when it is readable on desktop and phone.
Bug fix practice project
Who it is for: Beginner developers and students who want debugging practice.
What you learn: Expected behavior, actual behavior, reproduction steps, and smallest safe fixes.
What to ask Codex: Ask Codex to diagnose before fixing and explain the bug in plain English.
Create a tiny beginner bug-fix practice project. Include one intentional broken button or calculation bug, then help me debug it. First explain expected behavior, actual behavior, likely cause, and the smallest safe fix. After fixing it, tell me how to test that the bug is gone and no existing feature broke.
Course progress tracker
Who it is for: Students, creators, and WordPress course pages.
What you learn: Checklists, progress counts, local state, and lesson organization.
What to ask Codex: Ask for a tracker that clearly says whether progress is saved or only on-page.
Build a beginner-friendly course progress tracker for [course topic]. Include lesson checkboxes, a completion count, and a reset option. Explain whether progress is only on-page or saved in the browser. Do not add accounts, databases, or tracking. Use scoped CSS, vanilla JavaScript, and a mobile-friendly layout.
YouTube title generator template
Who it is for: Creators, YouTubers, and marketers testing content angles.
What you learn: Form inputs, template logic, output lists, and copy buttons.
What to ask Codex: Ask for a template-based generator, not an API-powered AI tool.
Build a YouTube title generator template. It should take inputs like topic, audience, format, and benefit, then generate title ideas from pre-written templates. No AI API, no backend, no external libraries. Include copy buttons and a reset button. Make it clear this is a template tool, not a live AI generator.
Sponsor ROI calculator
Who it is for: Creators, marketers, founders, and WordPress users measuring sponsor campaigns.
What you learn: Business logic, assumptions, inputs, results, and clear disclaimers.
What to ask Codex: Ask for transparent assumptions and a mobile-friendly calculator.
Build a self-contained sponsor ROI calculator for a WordPress Custom HTML block. Before coding, ask me to confirm the inputs and assumptions. Inputs could include sponsorship cost, expected views, click rate, conversion rate, and average customer value. Use scoped CSS and vanilla JavaScript. No external libraries or APIs. Show assumptions clearly and tell me what to test.
Not sure where to start? Answer four quick questions and get a recommended first project.
Choose your answers, then generate a recommendation.
Recommended project will appear here
We will explain why it fits your situation.
Generate a recommendation to see a starter prompt.
WordPress Custom HTML
Codex for WordPress Custom HTML Blocks
This is the practical WordPress path: ask Codex for one self-contained block, paste it into a draft page, test every interaction, then publish only when it works.
What a Custom HTML block is
A WordPress Custom HTML block lets you paste HTML, CSS, and JavaScript into a page or post. It is useful for simple tools, calculators, quizzes, prompt libraries, comparison tables, and interactive sections.
For beginners, the big advantage is control: one block is easier to preview, replace, back up, and understand than a full app with many moving parts.
The beginner rule
Use Custom HTML blocks for tools that can safely run in the visitor’s browser. Do not use them for anything that needs private data, protected accounts, payments, or secure server-side logic.
When in doubt, ask Codex to explain whether the idea belongs in a Custom HTML block before it writes code.
What belongs in a Custom HTML block
- Calculators
- Quizzes
- CTA blocks
- Comparison tables
- Prompt libraries
- Simple directories
- Checklists
- Interactive explainers
What does not belong in a Custom HTML block
- Private API keys
- Payment systems
- Login systems
- Private customer data
- Complex databases
- Anything that needs secure server-side logic
The WordPress-safe Codex checklist
Use this checklist before you paste anything into a live post or page.
Better WordPress Prompt Generator
Use this when you want Codex to plan, build, and QA a WordPress-ready tool. The generated output gives you a plan-first prompt, build prompt, QA prompt, and paste/testing checklist.
This creates a WordPress-safe prompt you can paste into Codex.
Your WordPress build prompt will appear below.
Describe the WordPress tool, then click Generate WordPress Custom HTML Prompt.
Optional advanced Open complete sample WordPress calculator prompt
Sample prompt: Build a WordPress Custom HTML calculator
Do not write code yet. First give me a beginner-friendly plan for a WordPress Custom HTML calculator. Goal: Build a self-contained calculator that I can paste into one WordPress Custom HTML block. Audience: [Describe who will use it.] Calculator idea: [Describe the calculator.] Inputs: [List the inputs.] Result: [Describe what the result should show.] Buttons: Include calculate, reset, and copy result buttons. Hard constraints: - Use only HTML, CSS, and vanilla JavaScript. - No React. - No external libraries. - No backend. - No API calls. - No API keys. - Use one unique wrapper ID. - Scope all CSS under that wrapper. - Keep JavaScript safely scoped. - Make it readable and usable on mobile. Before coding: Explain the fields, formula or logic, button behavior, mobile layout, and what I should test. After coding: Explain what changed, how to paste it into WordPress, and how to test every button before publishing.
Useful when something breaks Open WordPress troubleshooting guide
WordPress troubleshooting guide
If something breaks after pasting into WordPress, describe the exact symptom to Codex and ask for the smallest safe fix.
Debugging prompt tool
Useful when something breaksHow to Debug With Codex
Codex can fix bugs more reliably when it gets the exact problem, expected behavior, actual behavior, reproduction steps, error messages, and constraints. This turns “it does not work” into a clear debugging prompt.
Use plain language. You do not need to know the technical cause. Just describe what you did and what happened.
This turns expected behavior, actual behavior, and error details into a debugging prompt.
Your debugging prompt will appear below.
Describe the bug, then click Generate My Debugging Prompt.
Reviewing Codex work
Use this after Codex changes codeHow to Review Codex Changes Before Publishing
Codex can help you build and fix things, but you are still responsible for checking what changed, what might break, and whether the result matches your original goal. These copyable prompts help beginners slow down, test behavior, and review the work before publishing.
Why review matters
Codex can produce useful code, but the work is not finished just because the page looks different or the tool appears polished. Review is the calm step between “Codex made changes” and “I am ready to publish”: ask what changed, confirm the important behavior still works, and test the page yourself before accepting the result.
The beginner review loop
Ask what changed
Get a plain-English summary before testing.
Ask what might be affected
Find out which buttons, forms, layouts, or sections could have changed.
Test the main user flow
Click through the page like a visitor would.
Test mobile layout
Check that text, buttons, and cards still work on a phone-sized screen.
Ask for a final risk summary
Make Codex name any risks, assumptions, or follow-up checks.
What to ask Codex after every change
Explain what changed in plain English
Explain what changed in plain English. Do not assume I know technical terms. Tell me what you changed, why you changed it, and what I should look at first.
List files or sections changed
List every file, section, ID, button, form, or interactive feature you changed. For each one, explain what changed and whether existing behavior could be affected.
Create a manual test checklist
Create a manual test checklist for this change. Include page load, buttons, forms, copy buttons, results, reset behavior, mobile layout, horizontal scrolling, console errors, and privacy or API key risks.
Check for risky patterns
Check this change for risky patterns. Look for private data, API keys in front-end code, external libraries, tracking scripts, broad rewrites, duplicate IDs, unscoped CSS, broken buttons, and anything that could conflict with WordPress.
Review whether the result matches my original goal
Compare the result against my original goal: [paste original goal]. Tell me what matches, what does not match, what was skipped, and whether any changes went beyond the request.
Find the smallest safe follow-up improvement
Suggest the smallest safe follow-up improvement. Do not redesign, rewrite, or add new complexity. Explain why the improvement matters, what you would change, and how I should test it.
Manual testing checklist
Review Prompt Builder
Use this after Codex changes code. It turns your worries into a clear review prompt you can paste back into Codex.
Your generated review prompt will appear below.
Describe what Codex changed, then click Generate Review Prompt.
Extra copyable review prompts
Plan before coding prompt
I want to build [describe the project] for [audience]. Before writing code, please create a beginner-friendly plan. Include: - What you will build - What files you will change - What features will work in version one - What should be left for later - What I should review before you start Do not write code yet.
Build a WordPress Custom HTML block prompt
Build a single self-contained HTML block for WordPress. Project: [describe the tool or page] Audience: [describe who it is for] Rules: - Use only HTML, CSS, and vanilla JavaScript - No external libraries - No APIs or API keys - Scope all CSS under one unique wrapper ID - Keep JavaScript safe and scoped - Make all buttons work - Make it mobile responsive After building, explain what I should test.
Debug this broken button prompt
A button is not working in my project. Here is what I expected: [describe the expected behavior] Here is what happened instead: [describe the actual behavior] Please diagnose the likely cause before changing code. Then fix the smallest possible issue and explain: - What was broken - What changed - How I can test the button
Review the diff prompt
Please review the changes you made in beginner-friendly language. Explain: - What changed - Why it changed - What existing features might be affected - What I should test on desktop - What I should test on mobile - Any risks I should know about Do not make more changes until I approve.
Improve mobile layout prompt
Please improve the mobile layout for this page. Focus on: - Readable text sizes - Buttons that are easy to tap - Cards that stack cleanly - No overlapping sections - No tiny text - Strong contrast Keep the existing features working. After changing it, tell me exactly what to test.
Beginner capstone
Finish lineBeginner Capstone: Build and Publish One Useful Codex Project
By the end of the beginner path, you should be able to plan, prompt, build, review, test, and publish one small useful project.
Your capstone should be useful enough to publish, but small enough that you can explain the main user flow and test every important button yourself.
WordPress calculator
Who it is for: WordPress users, marketers, and founders.
Why it is a good capstone: It teaches inputs, results, reset behavior, copy buttons, and WordPress-safe constraints.
What Codex should build: A pasteable calculator with scoped CSS and vanilla JavaScript.
What to avoid: API keys, backend logic, external libraries, and unscoped CSS.
- Test every input.
- Click calculate, reset, and copy.
- Preview in WordPress before publishing.
Prompt library
Who it is for: Creators, marketers, teams, and students.
Why it is a good capstone: It teaches cards, categories, search, filtering, and copy buttons.
What Codex should build: A searchable set of editable prompt cards.
What to avoid: Database storage, login, tracking, or generated AI output that needs an API.
- Search for several terms.
- Try every filter.
- Copy multiple prompts.
Simple quiz
Who it is for: Educators, creators, and course builders.
Why it is a good capstone: It teaches answer logic, explanations, scoring, and reset behavior.
What Codex should build: A small multiple-choice quiz with supportive explanations.
What to avoid: Saved grades, accounts, databases, or complex learning management features.
- Answer every question.
- Check score accuracy.
- Reset and test again.
Landing page
Who it is for: Founders, creators, students, and service providers.
Why it is a good capstone: It teaches clear sections, calls to action, proof, and mobile readability.
What Codex should build: A focused one-page section with a clear CTA.
What to avoid: Fake testimonials, unsupported claims, payments, and tracking scripts.
- Read it on desktop and mobile.
- Click every link.
- Check that the CTA is clear.
Mini directory
Who it is for: Curators, marketers, founders, and creators.
Why it is a good capstone: It teaches structured cards, tags, search, and simple editorial data.
What Codex should build: A static directory that you can edit manually.
What to avoid: Databases, scraped data, live APIs, and private user submissions.
- Search by category.
- Check all links.
- Confirm cards stack on mobile.
Sponsor ROI calculator
Who it is for: Creators, marketers, and sponsorship teams.
Why it is a good capstone: It teaches business assumptions, input validation, and clear disclaimers.
What Codex should build: A calculator that shows assumptions and estimated outcomes.
What to avoid: Guaranteed results, hidden formulas, API calls, and private client data.
- Test realistic inputs.
- Check disclaimer copy.
- Confirm the result is understandable.
Course progress tracker
Who it is for: Students, course creators, and WordPress course pages.
Why it is a good capstone: It teaches checkboxes, counts, reset behavior, and local browser storage.
What Codex should build: A simple tracker with clear local-save messaging.
What to avoid: Accounts, grades, databases, analytics, or hidden tracking.
- Check items.
- Refresh the page.
- Reset progress and confirm it clears.
Checklist tool
Who it is for: Beginners, teams, creators, and operators.
Why it is a good capstone: It teaches useful state, simple layout, and practical testing.
What Codex should build: A clean checklist with progress count and reset option.
What to avoid: User accounts, private task data, backend storage, or complex permissions.
- Check and uncheck items.
- Confirm progress count updates.
- Test mobile tap targets.
Capstone Planner Tool
Answer these in plain English. The planner will create a plan-first prompt, a build prompt, a review/testing prompt, and a WordPress checklist when relevant.
Your capstone prompts will appear below.
Choose a capstone, then click Generate Capstone Plan.
Searchable beginner glossary
Beginner Coding Glossary for Codex Users
Search by term or filter by category. Each card explains what the word means, why it matters when using Codex, and the beginner mistake to avoid.
Showing 30 terms
Repository
Plain English: A project folder that can track code, files, and changes over time.
Why it matters for Codex: Codex may talk about the repository when it means the whole project it is working inside.
Mistake to avoid: Do not assume a repository is only for expert developers. Think of it as a managed project folder.
Repo
Plain English: A short nickname for repository.
Why it matters for Codex: Codex may say “repo” in summaries, plans, or review notes.
Mistake to avoid: Do not panic when you see the word. It usually just means “this project.”
Folder
Plain English: A container on your computer that holds files and sometimes other folders.
Why it matters for Codex: A clear practice folder keeps beginner projects safer and easier to review.
Mistake to avoid: Do not mix test files with important live website files until you understand the workflow.
File
Plain English: One saved item, such as an HTML page, CSS file, image, or note.
Why it matters for Codex: Codex often explains which files it will create or edit.
Mistake to avoid: Do not approve file changes if you do not know which file is being touched.
Branch
Plain English: A separate work path where changes can be tested before they become the main version.
Why it matters for Codex: Branches help keep experiments away from working code.
Mistake to avoid: Do not treat every branch as ready to publish.
Commit
Plain English: A saved checkpoint of changes in a project.
Why it matters for Codex: Commits can make it easier to understand what changed and when.
Mistake to avoid: Do not commit changes you have not tested or reviewed.
Pull request
Plain English: A request to review changes before combining them into the main project.
Why it matters for Codex: Pull requests are useful when you want a clear review step before shipping.
Mistake to avoid: Do not merge a pull request just because it exists. Review and test it first.
Diff
Plain English: A before-and-after view of what changed in the code or text.
Why it matters for Codex: A diff helps you review Codex’s work without reading the entire file.
Mistake to avoid: Do not skip the diff when Codex changes important files.
Terminal
Plain English: A text-based place to ask your computer to run commands.
Why it matters for Codex: Codex may use the terminal to inspect files, test code, or run local checks.
Mistake to avoid: Do not run commands you do not understand if they could delete or overwrite work.
Command
Plain English: A typed instruction that tells the computer to do something.
Why it matters for Codex: Codex may suggest commands for testing, opening, searching, or checking a project.
Mistake to avoid: Do not paste a command into your own computer unless you know what it does.
Dependency
Plain English: An outside tool, library, or package that a project needs in order to work.
Why it matters for Codex: Dependencies can make a project more powerful, but also harder to paste into WordPress.
Mistake to avoid: Do not add dependencies to a Custom HTML block project unless you truly need them.
Package
Plain English: A bundle of reusable code someone else made.
Why it matters for Codex: Codex may suggest packages when building larger projects.
Mistake to avoid: Do not assume a package is allowed in a no-dependency WordPress HTML block.
Environment
Plain English: The setup where a project runs, including files, settings, tools, and permissions.
Why it matters for Codex: A project can work in one environment and fail in another.
Mistake to avoid: Do not assume a file that works locally will behave exactly the same in WordPress.
Sandbox
Plain English: A restricted space where work can happen with safety limits.
Why it matters for Codex: Sandboxes can reduce risk while Codex inspects or edits files.
Mistake to avoid: Do not assume a sandbox means nothing can go wrong. Still review changes.
API key
Plain English: A private access code for an online service.
Why it matters for Codex: Some projects use API keys, but they must be protected.
Mistake to avoid: Never paste private API keys into public pages, screenshots, or code you do not understand.
Front end
Plain English: The visible part of a website or app that people click, read, and use.
Why it matters for Codex: WordPress Custom HTML tools are usually front-end projects.
Mistake to avoid: Do not ask for backend features if you only have a pasteable HTML block.
Back end
Plain English: The behind-the-scenes part that can handle data, accounts, databases, or server logic.
Why it matters for Codex: Some app ideas need a backend, which makes them more complex than a simple HTML block.
Mistake to avoid: Do not expect a Custom HTML block alone to securely store private user data.
HTML
Plain English: The structure and content of a web page.
Why it matters for Codex: Codex uses HTML to create headings, buttons, forms, cards, and sections.
Mistake to avoid: Do not put sensitive data in visible HTML.
CSS
Plain English: The styling that controls layout, colors, spacing, and how the page looks.
Why it matters for Codex: Good CSS makes generated tools readable and mobile-friendly.
Mistake to avoid: Do not let CSS affect your whole WordPress site. Keep it scoped.
JavaScript
Plain English: The browser code that makes buttons, forms, filters, calculators, and interactions work.
Why it matters for Codex: Codex often uses JavaScript to make a static page interactive.
Mistake to avoid: Do not assume a button works just because it looks clickable. Test it.
Build
Plain English: To create the project, feature, or working version.
Why it matters for Codex: “Build” can mean different things, so Codex needs a clear scope.
Mistake to avoid: Do not say “build an app” without saying what version one should include.
Test
Plain English: To check whether the project works as expected.
Why it matters for Codex: Testing catches broken buttons, layout issues, and logic mistakes before publishing.
Mistake to avoid: Do not publish just because Codex says it is done. Test it yourself.
Lint
Plain English: A code check that looks for style problems, possible errors, or patterns the project does not allow.
Why it matters for Codex: Linting can catch issues before they become visible bugs.
Mistake to avoid: Do not treat every lint message as scary. Ask Codex to explain it plainly.
Debugging
Plain English: Finding and fixing why something is not working.
Why it matters for Codex: Codex can help diagnose issues if you describe expected and actual behavior.
Mistake to avoid: Do not ask “fix this” without explaining what is broken.
Local
Plain English: Running or viewing something on your own computer.
Why it matters for Codex: Local testing is often safer before publishing to a real website.
Mistake to avoid: Do not assume local changes are live on the internet.
Cloud
Plain English: Online services or computers that run somewhere other than your own machine.
Why it matters for Codex: Some workflows use cloud tools for hosting, repositories, or deployment.
Mistake to avoid: Do not move beginner projects to cloud workflows before you understand the basics.
Worktree
Plain English: A working copy of a project where changes can happen.
Why it matters for Codex: Codex may work in a separate worktree to keep changes organized.
Mistake to avoid: Do not assume every worktree is the final version of your site.
AGENTS.md
Plain English: A project instruction file that tells Codex how to behave in that project.
Why it matters for Codex: It can remind Codex about project rules, constraints, and priorities.
Mistake to avoid: Do not leave important project rules only in your head. Write them down.
Prompt
Plain English: The instruction you give Codex.
Why it matters for Codex: Clear prompts help Codex plan, build, review, and debug more safely.
Mistake to avoid: Do not use vague prompts for important work. Include goal, context, constraints, and done criteria.
Context
Plain English: The background information Codex needs to make better decisions.
Why it matters for Codex: Context tells Codex what the project is, who it is for, and what matters most.
Mistake to avoid: Do not expect Codex to guess your audience, platform, or constraints.
Beginner quizzes
Check your understanding.
These short quizzes help you practice the habits that make Codex safer and easier to use. If you miss an answer, the explanation will point you in the right direction.
Start with one quiz. You are building the habit.
Project guidance
What Is AGENTS.md? Create Your First Project Instruction File
AGENTS.md is a file you put inside a project folder so Codex can read reusable instructions before it works. It helps you avoid repeating the same rules every time. Think of it as an instruction manual for Codex inside one project folder.
What to put in AGENTS.md
- Project purpose
- Audience
- Important files or folders
- Coding rules
- Style rules
- What Codex should avoid
- How to test
- What done means
- How Codex should summarize changes
What not to put in AGENTS.md
- Passwords
- API keys
- Private client data
- Vague motivational instructions
- Huge essays nobody will maintain
- Outdated rules
Keep AGENTS.md short and practical. Add rules only when they prevent repeated mistakes.
Optional advanced Open beginner AGENTS.md templates
Template: WordPress Custom HTML project
# Project overview This project is a WordPress Custom HTML block. It should be easy to paste into a WordPress page or post. # Audience Write for non-technical WordPress users and website visitors. # Important files or folders - Main HTML file or WordPress Custom HTML block. - Any backup copy saved before editing. # Technical constraints - Use only HTML, scoped CSS, and vanilla JavaScript. - No React. - No external libraries. - No backend. - No API calls. - No API keys. - Use one unique wrapper ID. # Content rules - Use plain English. - Keep labels, buttons, and instructions clear. # Do not do - Do not add private data, tracking, payments, logins, or databases. - Do not change unrelated sections. # Testing checklist - Test every button. - Check mobile layout. - Check for console errors. - Preview in WordPress before publishing. # Definition of done The block works in a WordPress Custom HTML block and is readable on desktop and mobile. # How to summarize changes Explain what changed, what to test, and any risks in plain English.
Template: Simple JavaScript app
# Project overview This project is a small JavaScript app that runs in the browser. # Audience Write for beginners who need clear labels, helpful feedback, and simple controls. # Important files or folders - Main HTML, CSS, and JavaScript files. - Any notes or test files that explain the expected behavior. # Technical constraints - Use HTML, CSS, and vanilla JavaScript. - Keep the code simple and readable. - Avoid unnecessary dependencies. - Keep JavaScript scoped. # Content rules - Explain technical choices in plain English. - Prefer small working features over a large unfinished app. # Do not do - Do not add login, payments, private data storage, API keys, or complex databases. - Do not rewrite unrelated working code. # Testing checklist - Test normal inputs. - Test empty or unusual inputs. - Test buttons, reset states, and mobile layout. # Definition of done The app works for the main user flow and the important controls have been tested. # How to summarize changes List what changed, why it changed, what to test, and any remaining risks.
Template: Course/lesson content project
# Project overview This project is beginner-friendly course or lesson content. # Audience Write for total beginners who may not know technical terms yet. # Important files or folders - Main lesson, course page, or prompt pack draft. - Source notes or accuracy notes that should be checked before publishing. # Technical constraints - Keep formatting clean and easy to repurpose. - Do not add external tools unless approved. # Content rules - Use plain English. - Be practical, encouraging, and accurate. - Explain jargon when it appears. - Prefer durable workflow guidance over fragile product claims. # Do not do - Do not invent product details. - Do not include private data, API keys, or unsupported claims. - Do not write huge sections that are hard to maintain. # Testing checklist - Check headings. - Check clarity. - Check beginner friendliness. - Check claims that may need official source verification. # Definition of done The content is useful, accurate, easy to scan, and ready for editing into a page or lesson. # How to summarize changes Explain what was added, what was clarified, and what still needs review.
Fill this out once for a project, then save the generated text as `AGENTS.md` in that project folder.
This creates project instructions you can save as AGENTS.md later.
Your AGENTS.md file will appear below.
Fill in the project guidance, then click Generate My AGENTS.md.
Beginner safety checklist
Check these before you publish.
Complete the safety items below to fill the safety progress count.
Free lead magnet
Future download plannedPreview the Free Codex Beginner Prompt Pack
50 copy/paste prompts for planning, building, debugging, reviewing, WordPress tools, and AGENTS.md.
The full downloadable version is planned. For now, copy the starter prompts below.
Recommended future page: /codex-beginner-prompt-pack/
Copy one prompt or copy all 12 starter prompts.
What is inside
- Plan-first prompts for fuzzy ideas
- WordPress Custom HTML prompts
- Calculator and quiz prompts
- Debugging prompts
- Review and testing prompts
- Mobile layout prompts
- AGENTS.md prompts
- Capstone project prompts
Showing 12 starter prompts
Plan before coding
Best for: New pages, fuzzy ideas, and anything important.
Difficulty: Beginner
Do not write code yet. I want to build or improve [project] for [audience]. First inspect the current page or project and give me a beginner-friendly plan. Explain what you would change, what you would avoid changing, what could break, and what I should approve before you edit anything.
Ask Codex to interview me first
Best for: Beginners who are unsure what details Codex needs.
Difficulty: Beginner
I am a beginner and my idea is still rough: [describe idea]. Before suggesting code, interview me with simple questions about the audience, goal, where this will be published, what features matter most, what to avoid, and how I will know it works. Then turn my answers into a clear Codex prompt.
Build a WordPress calculator
Best for: WordPress users, marketers, and founders.
Difficulty: Beginner
Build a self-contained WordPress Custom HTML calculator for [topic]. Use one unique wrapper ID, scoped CSS under that wrapper, and vanilla JavaScript. Include inputs for [inputs], a calculate button, reset button, result area, helpful validation, and mobile-friendly layout. No external libraries, API calls, backend, tracking, or API keys.
Build a prompt library
Best for: Creators, marketers, and teams.
Difficulty: Beginner
Plan and build a simple prompt library for [audience]. Include prompt cards, categories, search, and copy buttons. Use HTML, scoped CSS, and vanilla JavaScript only. No backend, database, tracking, or external libraries. Make the prompts easy for me to edit manually.
Debug a broken button
Best for: Buttons that look clickable but do nothing.
Difficulty: Beginner
A button is not working. Expected behavior: [what should happen]. Actual behavior: [what happens instead]. Steps I tried: [what I clicked or entered]. Please diagnose the likely cause before editing, make the smallest safe fix, and tell me exactly how to test it.
Review what Codex changed
Best for: Understanding a finished Codex edit.
Difficulty: Beginner
Review the changes before I accept them. Explain what changed, why it changed, what existing features might be affected, whether the result matches my original request, what I should test on desktop and mobile, and any risks or assumptions I should know.
Improve mobile layout
Best for: Pages that feel cramped on phones.
Difficulty: Beginner
Improve the mobile readability of this page without redesigning it. Focus on readable text, comfortable spacing, buttons that are easy to tap, clean stacking, and no overlapping or overflowing content. Preserve existing features and tell me exactly what to test.
Add accessibility improvements
Best for: Forms, buttons, quizzes, and interactive tools.
Difficulty: Beginner
Review this page for beginner-friendly accessibility improvements. Check labels, button text, keyboard access, focus states, contrast, readable text, form instructions, and screen-reader-friendly status messages. Suggest focused fixes without redesigning the page or breaking existing features.
Create an AGENTS.md file
Best for: Reusable project rules.
Difficulty: Beginner
Create a short AGENTS.md file for this project. Include project overview, audience, technical constraints, content rules, what not to do, testing checklist, definition of done, and how to summarize changes. Keep it practical, beginner-friendly, and easy to maintain.
Build a first project plan
Best for: Choosing the first tiny build.
Difficulty: Beginner
Help me plan my first tiny Codex project. I am a [role] building for [audience]. My idea is [idea]. Recommend the smallest useful version, what to build first, what to leave for later, what to avoid, and how I should test it before publishing.
Create a testing checklist
Best for: Checking a tool before publishing.
Difficulty: Beginner
Create a manual testing checklist for this [page/tool]. Include page load, buttons, forms, copy buttons, reset buttons, result displays, empty states, mobile layout, horizontal scrolling, console errors, and any privacy or API key risks.
Final review before publishing
Best for: The last safety check.
Difficulty: Beginner
Before I publish, do a final beginner-friendly review. Check whether the project matches the goal, buttons work, forms work, copy buttons work, mobile layout is readable, no private data or API keys are exposed, and I have a clear manual testing checklist. Tell me if I should stop and fix anything first.
Future download
Future version: PDF + markdown file + WordPress starter prompts.
No form is connected yet. No email service, backend, tracking, or fake download has been added.
Future course expansion
Future Course Expansion
The beginner path is live on this page. These future lessons and videos will expand the course over time. Planned lessons and videos are roadmap items until they are published.
Full Codex Beginner Course Lesson Plan
Course lesson plan
Full Codex Beginner Course Lesson Plan
This course hub is the starting point. The full learning path can expand into dedicated Kingy AI lessons for each beginner skill.
What Is OpenAI Codex?
What you learn: What Codex is, what it can help with, and why human review still matters.
Beginner outcome: You can describe Codex as an AI coding agent you direct, constrain, review, and test.
Codex Setup for Beginners
What you learn: How to prepare a safe practice folder, save backups, and start with low-risk work.
Beginner outcome: You can set up a beginner practice space before touching important pages.
Files, Folders, and Projects
What you learn: The basic words Codex may use when talking about files, folders, pages, and projects.
Beginner outcome: You can understand what Codex is inspecting or changing.
Terminal, GitHub, and Basic Terms
What you learn: Plain-English meanings for terminal, repo, branch, commit, pull request, and diff.
Beginner outcome: You know which terms matter now and which ones can wait.
How to Prompt Codex
What you learn: The goal, context, constraints, and done-when formula for beginner-safe prompts.
Beginner outcome: You can generate a clear prompt without knowing technical jargon.
Plan Before Coding
What you learn: How to make Codex inspect, explain, and plan before it edits code.
Beginner outcome: You can slow Codex down before a task becomes risky.
Build Your First Landing Page
What you learn: How to plan a simple page with sections, proof, CTA, and mobile layout.
Beginner outcome: You can ask Codex for a small landing page you can review yourself.
Build Your First WordPress Calculator
What you learn: Inputs, results, reset behavior, copy buttons, scoped CSS, and WordPress preview testing.
Beginner outcome: You can prompt for a pasteable calculator without adding backend complexity.
Debugging With Codex
What you learn: How to describe expected behavior, actual behavior, reproduction steps, and constraints.
Beginner outcome: You can ask Codex for the smallest safe fix instead of saying “fix this.”
Reviewing Codex Work
What you learn: How to ask what changed, what might break, and what to test before publishing.
Beginner outcome: You can review Codex output before trusting it.
Codex for WordPress Custom HTML Blocks
What you learn: What belongs in a Custom HTML block, what does not, and how to test before publishing.
Beginner outcome: You can request WordPress-safe HTML, CSS, and JavaScript from Codex.
What Is AGENTS.md?
What you learn: How to create a short instruction manual Codex can use inside a project folder.
Beginner outcome: You can generate reusable project rules without storing secrets.
Beginner Codex Project Ideas
What you learn: Which projects are safe first builds and how to choose one based on your role.
Beginner outcome: You can pick one tiny project instead of starting with a giant app.
Capstone: Build and Publish a Useful Tool
What you learn: How to plan, build, review, test, and publish one small useful project.
Beginner outcome: You finish with a real project and a safer repeatable workflow.
Planned lessons should be treated as content roadmap placeholders until published.
Watch the Codex Beginner Course on Kingy AI
Video roadmap
Watch the Codex Beginner Course on Kingy AI
Each lesson can become a short practical video walkthrough. Until the videos are live, use this section as the course video roadmap.
What Is OpenAI Codex?
What the viewer will see: A plain-English explanation of Codex as an AI coding agent you guide and review.
Suggested demo: Compare a vague “build me an app” request with a clear plan-first prompt.
How to Prompt Codex as a Beginner
What the viewer will see: The goal, context, constraints, and done-when formula in action.
Suggested demo: Use the Prompt Builder to generate plan-first, build, and review prompts.
Plan Before Coding
What the viewer will see: How to ask Codex to inspect, explain, and wait before editing code.
Suggested demo: Rewrite “make my website better” into a safer plan-first prompt.
Build a WordPress Calculator With Codex
What the viewer will see: How to plan inputs, results, buttons, and a WordPress-safe Custom HTML block.
Suggested demo: Generate a calculator prompt, build a self-contained block, and preview it before publishing.
Debug a Broken Button With Codex
What the viewer will see: How expected behavior, actual behavior, and reproduction steps make debugging easier.
Suggested demo: Fix one broken button with the smallest safe change and retest it.
Review Codex Changes Before Publishing
What the viewer will see: A beginner review loop for checking what changed, what might break, and what to test.
Suggested demo: Ask for a change summary, risk summary, and manual testing checklist.
Create Your First AGENTS.md File
What the viewer will see: How AGENTS.md acts like an instruction manual for Codex inside a project folder.
Suggested demo: Generate a short AGENTS.md with project purpose, technical rules, testing, and done criteria.
Beginner Capstone Walkthrough
What the viewer will see: The full beginner workflow: plan, prompt, build, review, test, and publish one small useful project.
Suggested demo: Choose a capstone, generate the prompts, build the first version, and run the final checklist.
Replace these placeholders with YouTube embeds or links after each video is published.
Sources and trust
Optional advancedSources and Accuracy Notes
This course separates durable beginner workflow advice from product-specific Codex details that can change. Last updated: May 25, 2026.
Optional advanced Open source categories and official links
Source categories
Use these official sources when checking current Codex product details, prompting guidance, AGENTS.md behavior, and search documentation before publishing exact claims.
Accuracy promise
- We do not treat Codex as magic.
- We recommend starting with backups and practice projects.
- We avoid telling beginners to paste private API keys or sensitive data into front-end code.
- We separate durable workflow advice from product-specific claims.
- We recommend checking official docs for current Codex features and availability.
What this course is not
This course is not:
- A guarantee that Codex-generated code is always correct
- A replacement for human review
- A complete software engineering degree
- A guide to exposing private API keys
- A recommendation to edit production systems without backups
This course is a beginner workflow for planning, prompting, reviewing, debugging, and safely shipping small useful projects.
Kingy AI content cluster
Continue Learning on Kingy AI
Some of these guides are already live. Others are planned as this course expands into a full Codex learning hub.
What Is OpenAI Codex?
A deeper Kingy AI guide to what Codex is, how it works, and how it fits into AI coding workflows.
Best Codex Prompts for Beginners
A copy/paste prompt guide for planning, building, debugging, reviewing, and testing small projects safely.
Planned guide.
How to Use Codex With WordPress Custom HTML Blocks
A WordPress-focused guide for calculators, quizzes, prompt libraries, comparison tables, and safe paste/testing habits.
Planned guide.
What Is AGENTS.md?
A deep guide to AGENTS.md, repository instruction files, what belongs inside them, and how coding agents use them.
How to Debug Code With Codex
A practical guide to describing expected behavior, actual behavior, reproduction steps, errors, and the smallest safe fix.
Planned guide.
Codex Project Ideas for Beginners
A curated list of first projects that are small enough to understand, test, explain, and safely improve.
Planned guide.
Codex vs Other AI Coding Agents
A practical map of Codex, Claude Code, Cursor, Windsurf, Manus, and the broader AI coding-agent landscape.
AI Coding Tools for Beginners
A no-jargon guide to AI coding tools for people who want to build useful projects without becoming traditional software engineers first.
OpenAI Codex Command Guide
A practical reference for Codex commands, workflows, and beginner-friendly command concepts.
FAQ
Beginner questions, straight answers.
For AI coding tools, dev tools, and agent platforms
Want your AI product explained to practical AI builders?
Kingy AI creates practical AI tutorials, demos, comparisons, and sponsored videos for creators, founders, marketers, operators, and builders who want to understand what tools can actually do.
This Codex beginner course attracts people who are learning how to build with AI coding agents, WordPress tools, prompt workflows, debugging, review, and safe publishing habits.
A fit review helps decide whether a sponsored tutorial, demo, or comparison would make sense for this audience.
Want your AI product explained to a large AI-native audience?
Kingy AI helps AI companies turn complex products into clear, useful YouTube videos that drive awareness, product understanding, demos, clicks, and search visibility.
