# 25 Copy-Paste Prompts to Build Apps With AI **By NonDev Apps** — https://nondevapps.com A beginner-friendly prompt pack for non-developers using ChatGPT, Claude, Codex, GitHub, Android Studio, and Xcode. --- ## How to use this guide 1. Copy one prompt at a time. Do not paste five at once. 2. Replace the bracketed placeholders — [APP IDEA], [TASK], [BUG] — with your actual details. 3. Use ChatGPT or Claude for thinking, planning, and preparing Codex prompts. 4. Use Codex for changing files inside your project. 5. Commit to GitHub before every big change. Git is your undo button. --- ## Section 1 — Find a simple app idea ### Prompt 01 — Find painful everyday problems **When to use:** When you do not know what app to build. ``` I want to build a simple app, but I am not a developer. Help me find app ideas based on everyday problems. Ask me one question at a time about my work, life, routines, frustrations, and people I understand. Do not suggest app ideas until you have asked at least 5 questions. ``` **Beginner note:** Good apps usually start from real pain, not random ideas. --- ### Prompt 02 — Score my app idea brutally **When to use:** When you already have an idea and need honesty. ``` Act as a brutally honest product reviewer. Review this app idea: [APP IDEA]. Score it from 1 to 10 for pain level, simplicity, ability to build with AI, competition, money potential, and likelihood that real users care. Tell me if I should build it, simplify it, or kill it. ``` **Beginner note:** Do this before asking Codex to build anything. --- ### Prompt 03 — Find the smallest useful version **When to use:** When your idea feels too big. ``` Here is my app idea: [APP IDEA]. Cut it down to the smallest useful first version. Remove every feature that is not needed for version 1. Give me: one target user, one main problem, one core feature, and what the app should NOT do yet. ``` **Beginner note:** Your first app should be small enough to explain in one sentence. --- ## Section 2 — Turn the idea into a build plan ### Prompt 04 — Create a simple app blueprint **When to use:** Before asking Codex to build. ``` Create a simple app blueprint for this idea: [APP IDEA]. Explain it for a non-developer. Include: target user, main problem, core screens, key user actions, data that needs to be saved, and what version 1 should include. ``` **Beginner note:** This gives Codex a map before it touches files. --- ### Prompt 05 — Create the first screen list **When to use:** When you need to know what pages or screens the app needs. ``` For this app idea: [APP IDEA], list only the screens needed for version 1. For each screen, explain what the user sees, what buttons exist, and what happens when each button is tapped. Keep it simple and avoid extra features. ``` **Beginner note:** Screens are easier to build than vague features. --- ### Prompt 06 — Define what "done" means **When to use:** Before giving work to Codex. ``` For this task: [TASK], define what "done" means. Give me a clear checklist that Codex can use to know when the work is complete. Include build checks, visual checks, user flow checks, and things that must not break. ``` **Beginner note:** AI works better when you define the finish line. --- ## Section 3 — Ask ChatGPT / Claude properly ### Prompt 07 — Ask questions before answering **When to use:** When your request is not fully clear. ``` I want to [TASK]. Ask me one question at a time before you answer. Do not assume missing details. Only give the final answer after you understand the goal, context, constraints, and what "done" means. ``` **Beginner note:** This stops AI from guessing too early. --- ### Prompt 08 — Explain this like I am non-technical **When to use:** When AI gives you jargon. ``` Explain this to me like I am a smart non-developer. Avoid jargon. Use simple examples. Tell me what matters, what I can ignore, and what exact next step I should take. ``` **Beginner note:** You do not need to understand everything. You need to understand the next safe move. --- ### Prompt 09 — Turn messy notes into a clean Codex prompt **When to use:** When you have rough thoughts and need a proper task prompt. ``` Turn these messy notes into a clear Codex prompt: [PASTE NOTES]. The prompt must include: Goal, Context, Constraints, Files likely involved, What not to change, Done when, and Required final report. ``` **Beginner note:** This is one of the most useful workflows. --- ### Prompt 10 — Create a one-step-at-a-time plan **When to use:** When you feel overwhelmed. ``` Break this project into small steps for a non-developer: [PROJECT/TASK]. Give me only the next step first. Wait for me to confirm before giving the next step. ``` **Beginner note:** This keeps you from drowning. --- ## Section 4 — Use Codex safely ### Prompt 11 — Audit before changing files **When to use:** Before asking Codex to fix or improve code. ``` Before changing any files, inspect the relevant code and give me an audit. Explain what is currently happening, what the likely problem is, which files matter, and the safest fix plan. Do not edit files yet. ``` **Beginner note:** Audit first. Fix second. --- ### Prompt 12 — Make one controlled change **When to use:** When you want Codex to avoid changing too much. ``` Make only this change: [CHANGE]. Do not refactor unrelated code. Do not rename files. Do not change styling outside this area. After the change, explain exactly which files changed and why. ``` **Beginner note:** Most AI damage comes from doing too much. --- ### Prompt 13 — Fix a bug without changing behavior **When to use:** When something is broken but you do not want a redesign. ``` Fix this bug: [BUG]. Preserve existing behavior and design unless the bug requires a small change. Do not add new features. Do not rewrite the whole file. Run the relevant checks and report what changed. ``` **Beginner note:** Bug fixing is not the same as improvement. --- ### Prompt 14 — Review your own changes **When to use:** After Codex edits files. ``` Review the changes you just made. Look for bugs, broken user flows, missing edge cases, accessibility issues, type errors, and accidental unrelated changes. Be critical. If something is risky, tell me before changing more files. ``` **Beginner note:** Make AI check its own work. --- ### Prompt 15 — Prepare a safe Git checkpoint **When to use:** Before a big change. ``` Before we continue, tell me what Git checkpoint I should create. Give me a short commit message and explain what is currently safe to save. Do not make more code changes until this checkpoint is done. ``` **Beginner note:** GitHub is your undo button. --- ## Section 5 — Improve UI without making a mess ### Prompt 16 — Brutal UI review **When to use:** When a screen looks ugly or boring. ``` Act as a top 1% mobile and web UI reviewer. Review this screen/page: [DESCRIBE OR PASTE SCREENSHOT NOTES]. Be brutally honest. Score layout, spacing, typography, contrast, visual hierarchy, premium feel, and user clarity. Tell me the biggest 3 fixes only. ``` **Beginner note:** Do not ask for "make it beautiful." Ask for specific review. --- ### Prompt 17 — Premium polish without redesign **When to use:** When the design is close but needs refinement. ``` Polish this UI without redesigning it. Improve spacing, typography, contrast, hierarchy, button states, and card rhythm. Do not change the overall layout or brand direction. Keep the changes controlled and explain what changed. ``` **Beginner note:** Polish is safer than redesign. --- ### Prompt 18 — Fix washed-out design **When to use:** When everything looks too soft or low contrast. ``` This UI feels too soft and washed out. Improve headline contrast, title weight, divider definition, spacing rhythm, and CTA strength. Do not add flashy effects. Keep the design calm and premium. ``` **Beginner note:** Premium does not mean blurry, pale, and over-rounded. --- ### Prompt 19 — Mobile layout audit **When to use:** Before launch. ``` Audit this page for mobile layout problems. Check spacing, tap targets, wrapping, overflow, sticky headers, form fields, buttons, and readability. Give me a fix plan before changing code. ``` **Beginner note:** Most users will judge you on mobile. --- ## Section 6 — Prepare for launch ### Prompt 20 — Launch checklist **When to use:** Before putting your app or website live. ``` Create a launch checklist for this project: [PROJECT]. Include technical checks, design checks, content checks, privacy/legal checks, analytics/email checks, mobile checks, and rollback plan. Explain it for a non-developer. ``` **Beginner note:** Launch is a checklist, not a feeling. --- ### Prompt 21 — Privacy and trust check **When to use:** Before collecting emails or user data. ``` Review this product for privacy and trust risks: [PRODUCT OR WEBSITE]. What data is collected? What needs to be disclosed? What wording could mislead users? What should the privacy policy mention? Explain it simply. ``` **Beginner note:** If you collect data, you need trust. --- ### Prompt 22 — Store and production readiness review **When to use:** Before Play Store, App Store, or public website launch. ``` Act as a production readiness reviewer. Review this project for launch risks: [PROJECT DETAILS]. Check broken flows, placeholder text, fake promises, missing legal pages, email delivery, payment status, mobile issues, and support/contact paths. ``` **Beginner note:** Public users find everything you forgot. --- ## Section 7 — When things break ### Prompt 23 — Explain the error **When to use:** When you see a scary error. ``` Explain this error in simple terms: [PASTE ERROR]. Tell me what it means, whether it is dangerous, the most likely cause, and the safest next step. Do not give code yet unless I ask. ``` **Beginner note:** Do not panic. First understand the error. --- ### Prompt 24 — Create a safe fix prompt for Codex **When to use:** When ChatGPT understands the problem and you need Codex to fix it. ``` Create a safe Codex prompt to fix this problem: [ERROR OR PROBLEM]. The prompt must tell Codex to inspect first, avoid unrelated changes, make the smallest safe fix, run checks, and report files changed. ``` **Beginner note:** Use ChatGPT to prepare the Codex instruction. --- ### Prompt 25 — Recovery plan after AI broke something **When to use:** When Codex or Claude made things worse. ``` Something broke after AI changed the project. Help me recover safely. Ask me one question at a time. First, help me check Git status and identify changed files. Then help me decide whether to revert, fix forward, or create a backup branch. ``` **Beginner note:** There is almost always a safe recovery path if you use Git. --- ## The golden rule Do not ask AI to build your whole dream at once. Ask it to help you make the next safe move. > Small prompt. Clear task. Safe checkpoint. --- Read the full interactive guide at: https://nondevapps.com/resources/25-prompts-to-build-apps-with-ai Browse the Latest Lessons archive: https://nondevapps.com/daily-advice NonDev Apps — https://nondevapps.com