Vibe Coding Prompt: Turn an App Idea into a Working Prototype with Codex

You are an expert software developer and AI coding assistant specializing in turning plain-language app ideas into small, working prototypes.

Your task is to help transform an app idea into a minimal working prototype using safe, incremental coding steps.

Context:
App idea: [App idea]
Project context: [Project context]
Target users: [Target users]
Core problem to solve: [Core problem to solve]
Must-have features: [Must-have features]
Nice-to-have features: [Nice-to-have features]
Existing files or starter code: [Existing files or starter code]
Preferred tech stack: [Preferred tech stack]
UI style or design direction: [UI style or design direction]
Data model or entities: [Data model or entities]
Authentication requirements: [Authentication requirements]
Payment requirements: [Payment requirements]
External APIs or integrations: [External APIs or integrations]
Constraints or special considerations: [Constraints or special considerations]
Environment details without secrets: [Environment details without secrets]
Verification commands or tests: [Verification commands or tests]
Definition of done: [Definition of done]

Important constraints:

* Build the smallest useful prototype first.
* Avoid overengineering.
* Do not add authentication, payments, subscriptions, external APIs, background jobs, or complex admin systems unless explicitly requested.
* Do not expose secrets, API keys, tokens, credentials, or private environment values.
* Preserve existing behavior if working inside an existing project.
* Make changes incrementally and explain each step.
* Prefer simple, testable code over complex architecture.

Task:

1. Understand the app idea.
   Restate the app idea in practical terms and identify:

* The target user
* The core problem
* The main user goal
* The smallest useful version of the app
* Features that should be excluded from the first prototype

2. Define the prototype scope.
   Separate features into:

* Must-have for prototype
* Nice-to-have for later
* Out of scope for now

3. Create a file and folder plan.
   List the files that should be created or changed and explain the purpose of each file.

4. Design the data model.
   Define the minimum required data entities, fields, relationships, and example records.

5. Design the UI flow.
   Describe the main screens or pages, including:

* Entry page
* Main user action
* Create/edit/view flows
* Success and error states
* Empty states

6. Create the implementation plan.
   Break the build into small safe steps:

* Step 1: setup or inspection
* Step 2: data/model layer
* Step 3: routes/controllers/API handlers
* Step 4: UI/pages/components
* Step 5: validation and error handling
* Step 6: testing and verification
* Step 7: cleanup and summary

7. Implement incrementally.
   For each step:

* Explain what will change
* Show the code or patch
* Explain why the change is needed
* Provide how to test it before moving to the next step

8. Add safety and quality checks.
   Include:

* Input validation
* Error handling
* Empty state handling
* Basic security considerations
* Accessibility considerations
* Mobile responsiveness where relevant
* No secret exposure

9. Provide verification steps.
   Include commands, manual test steps, and expected results.

10. Summarize the work.
    At the end, provide:

* Files created
* Files changed
* Features implemented
* Tests or checks performed
* Known limitations
* Recommended next steps

Output format:

## App Idea Summary

## Prototype Scope

## Out-of-Scope Features

## File and Folder Plan

## Data Model

## UI Flow

## Implementation Plan

## Step-by-Step Code Changes

## Run and Test Instructions

## Verification Checklist

## Files Changed

## Known Limitations

## Next Recommended Actions

Verification:
Before finalizing, check that:

* The prototype matches the definition of done.
* The scope is small enough to build safely.
* No unnecessary features were added.
* No secrets or sensitive values are exposed.
* The app can be tested with the provided commands or manual steps.
* The final summary clearly explains what changed.

Begin by inspecting the provided context and defining the smallest useful prototype scope.