The Exact Prompts I Use to Start Any Project With AI

I am building [PROJECT NAME].
 
It is a [TYPE OF APP — web app / mobile app / CLI tool / etc].
 
The main users are [WHO USES IT].
 
The core problem it solves is [ONE SENTENCE].
 
Tech stack:
- Frontend: [Next.js / React Native / etc]
- Backend: [ASP.NET Core / Node.js / etc]
- Database: [PostgreSQL / MongoDB / etc]
- Auth: [Clerk / NextAuth / Supabase / etc]
 
Do not write any code yet. Just confirm you understand the project.

Based on the project I described, suggest a clean folder structure.
 
Rules:
- Monorepo with separate apps/ folder for web and mobile if needed
- Shared types in a packages/types folder
- Keep it simple — no over-engineering
- Use [Next.js App Router / Pages Router] conventions
 
Show me only the folder structure. No code yet.

Set up the following shared infrastructure. Do not build any features yet.
 
1. Database connection with [Prisma / Drizzle / EF Core]
2. Base API client for frontend with error handling
3. Auth middleware that protects routes
4. Shared TypeScript types folder
5. Environment variables setup with .env.example
 
One file at a time. Start with database connection only.

I am building the [FEATURE NAME] feature.
 
Before writing any code, define the API contract.
 
The API should return:
- [Describe what data you need]
 
Write the TypeScript interface and the API endpoint definition only.
No database code. No UI code. Just the contract.

I am building the Course Listing feature.
 
Before writing any code, define the API contract.
 
The endpoint is GET /api/courses
 
It should return a list of courses. Each course has:
- id (number)
- title (string)
- instructor name (string)
- thumbnail URL (string)
- price (number)
- rating (decimal)
- total students (number)
 
Write the TypeScript interface only. No other code.

Now build the backend for the [FEATURE NAME] feature.
 
Use the contract we defined above.
 
Steps:
1. Create the database schema / migration for this feature only
2. Build the service layer with the database query
3. Build the API controller / route handler
4. Make sure GET /api/[endpoint] returns exactly the JSON from our contract
 
Do it one step at a time. Start with the database schema only.

Now build the frontend UI for [FEATURE NAME].
 
Rules:
- Use hardcoded mock data matching our contract — do NOT call the API yet
- Focus only on design — layout, spacing, colors, hover states
- Make it look production quality
- Use [Tailwind / CSS Modules / styled-components]
 
The mock data to use:
[paste your JSON contract here]
 
Build the component only. No API calls. No React Query. Just the UI with fake data.

Now connect the [FEATURE NAME] UI to the real API.
 
Steps:
1. Replace hardcoded mock data with a React Query / SWR hook
2. Call GET /api/[endpoint]
3. Handle loading state
4. Handle error state
5. Run the linter
6. Make sure it builds with zero errors
 
Show me only the changes needed. Do not rewrite the whole component.

Here is a list of all features for [PROJECT NAME]:
 
[paste your full feature list]
 
Sort them into three buckets:
1. Core — without these the app cannot function
2. Important — these make the app genuinely good
3. Nice to have — cut these if time runs short
 
Explain your reasoning for each bucket.

We have [NUMBER] developers working on this project simultaneously.
 
Features being built in parallel:
- Developer A: [feature]
- Developer B: [feature]
- Developer C: [feature]
 
Identify:
1. Which features share database tables
2. Which API endpoints might conflict
3. Which TypeScript types need to be in shared packages
4. What order should database migrations run
 
Give me a conflict prevention checklist.

My project: [PROJECT NAME]
Current slice I am working on: [FEATURE NAME]
Current step I am on: [Contract / API / Mock UI / Connect]
 
What is the exact next thing I should do right now?
Give me one specific action, not a list.

I am working on [FEATURE NAME].
I am on Step [1/2/3/4] of the vertical slice loop.
 
The problem:
[describe exactly what is wrong]
 
What I expected:
[describe what should happen]
 
What is actually happening:
[describe what is happening]
 
The relevant code:
[paste the specific file or function — not your entire codebase]
 
Give me one fix at a time. Do not rewrite everything.

Review this code for the [FEATURE NAME] feature.
 
Check for:
1. TypeScript errors or any use of 'any' type
2. Missing error handling
3. Security issues — SQL injection, exposed secrets, unprotected routes
4. Performance issues — unnecessary re-renders, N+1 queries
5. Anything that does not match our original contract
 
The code:
[paste the feature code]
 
Give me a prioritized list of issues. Critical first.

For this entire project, follow these rules:
 
1. Never write more than one file at a time unless I explicitly ask
2. Always confirm you understand before writing code
3. When I say "build X", ask me what step we are on first
4. Never change code outside the file we are currently working on
5. If you are unsure about something, ask — do not guess
6. After every file you write, wait for my confirmation before continuing
 
Confirm you understand these rules.