AI Prompts for Cursor Prompts for Vibe Coding: Build Apps with AI at Speed

I am starting a new coding project with Cursor and want to write a comprehensive project brief before writing any code. The project is [DESCRIBE WHAT YOU ARE BUILDING: APP, TOOL, FEATURE, WEBSITE]. The tech stack I want to use is [DESCRIBE: LANGUAGE, FRAMEWORK, DATABASE, HOSTING]. My experience level is [DESCRIBE: COMPLETE BEGINNER / SOME CODING BACKGROUND / EXPERIENCED IN [X] but new to [Y]]. Write a Cursor project brief that I can paste at the start of every Cursor session to ensure: consistent code style and architecture across sessions, awareness of my constraints (performance, cost, existing code if any), understanding of who the end user is and what they need, and any specific patterns or anti-patterns I want Cursor to follow or avoid. Format it as a CLAUDE.md or cursor-rules file I can save in my project root.

I want to build [DESCRIBE YOUR PROJECT] but I am not sure which tech stack to choose. My goals are: [DESCRIBE: BUILD QUICKLY, MAKE SOMETHING SCALABLE, KEEP COSTS LOW, USE A SPECIFIC LANGUAGE I KNOW, ETC.]. I am considering [LIST OPTIONS IF ANY] or I am open to any recommendation. Ask Cursor to: recommend a specific tech stack for my project goals, explain the key tradeoffs of the recommended stack vs alternatives, outline the folder structure for a project using this stack, and write the initial setup commands and configuration files I need to get started. My intended hosting is [DESCRIBE IF KNOWN: VERCEL, RAILWAY, AWS, ETC.]. I want the setup to work immediately without complex configuration.

Write a .cursorrules file for my [TECH STACK] project that will guide Cursor's code generation across all sessions. The project is [DESCRIBE]. My code style preferences are [DESCRIBE: TYPESCRIPT STRICT MODE, FUNCTIONAL COMPONENTS ONLY, NO CLASS COMPONENTS, ETC.]. Patterns I always want Cursor to follow: [DESCRIBE: ERROR HANDLING APPROACH, STATE MANAGEMENT STYLE, API CALL PATTERNS]. Patterns I never want Cursor to use: [DESCRIBE]. Include in the rules file: the project overview, the tech stack and version numbers, the component and file naming conventions, the patterns for common operations (API calls, form handling, routing), and any context about the existing codebase structure that Cursor needs to generate consistent code.

I want to build [DESCRIBE FEATURE] in my existing [TECH STACK] project. Before writing any code, help me plan the implementation. The feature needs to: [DESCRIBE WHAT IT SHOULD DO]. The existing code structure is [DESCRIBE YOUR CURRENT FILES AND ARCHITECTURE]. Use Cursor to: break the feature into specific implementation steps in the right order, identify which existing files will need to be modified and which new files will be created, flag any potential issues or edge cases I should think through before starting, and write the implementation plan as a numbered list I can follow step by step, checking off each item as Cursor completes it. A good plan prevents the situation where Cursor writes 200 lines of code that need to be rewritten because the architecture was wrong.

I want to build [DESCRIBE THE APP: WHAT IT DOES, WHO USES IT, THE CORE FEATURE] from scratch using Cursor. I have no existing code. My technical background is [DESCRIBE]. Using Cursor, walk me through the complete setup: (1) initializing the project with the right commands and directory structure, (2) installing dependencies and configuring the development environment, (3) creating the first few files and components that establish the architecture pattern for the rest of the project, (4) getting a "hello world" version running locally that I can verify before building features. I want to avoid setup issues that waste time before the real building starts. Write each step as a Cursor prompt I can paste in sequence.

I want to build this feature: [DESCRIBE WHAT YOU WANT]. My tech stack is [DESCRIBE]. Write a Cursor feature request prompt that: specifies the exact behavior the feature should have (input, process, output), describes the UI component appearance and interaction if applicable, specifies where in the existing code this feature connects (which files it reads from, writes to, or extends), includes any validation or error handling that should be built in, and specifies the code style that matches my existing project. A well-specified feature request produces working code in one pass; a vague one produces code that works in the demo but breaks in real use.

I need to add user authentication to my [TECH STACK] project. The auth flow should support: [DESCRIBE: EMAIL/PASSWORD LOGIN, GOOGLE OAUTH, MAGIC LINK, ETC.]. My project uses [DATABASE: POSTGRESQL / SQLITE / MONGODB] and [AUTH LIBRARY IF ANY: NEXTAUTH / SUPABASE AUTH / CLERK / CUSTOM]. Write a series of Cursor prompts that build the authentication flow in the right order: (1) database schema for users, (2) auth configuration and setup, (3) signup and login forms with validation, (4) session management and protected routes, (5) password reset or account management. For each step, write a specific Cursor prompt that builds only that piece without breaking what came before. Include the test cases I should verify after each step.

I need to build a complete create-read-update-delete feature for [ENTITY: E.G., BLOG POSTS, PRODUCTS, USER PROFILES] in my [TECH STACK] project. The entity has these fields: [LIST FIELDS AND TYPES]. Write the Cursor prompts for: (1) the database table or schema definition, (2) the API routes or server functions for each CRUD operation, (3) the list view component that shows all records, (4) the form component for creating and editing records, (5) the delete confirmation flow. Each prompt should specify the input/output contract so the pieces connect correctly. Include any data validation that should happen at the API layer and any optimistic UI updates if using a modern framework.

I need Cursor to build a [DESCRIBE COMPONENT: DATA TABLE, DROPDOWN MENU, MODAL, FORM, CHART, ETC.] component for my [FRAMEWORK: REACT / VUE / SVELTE] project. The component should: accept these props [LIST PROPS AND THEIR TYPES], display [DESCRIBE THE VISUAL OUTPUT], handle these user interactions [DESCRIBE EVENTS AND BEHAVIORS], and integrate with [DESCRIBE HOW IT CONNECTS TO STATE OR DATA]. Style using [TAILWIND / CSS MODULES / STYLED COMPONENTS / ETC.] and match this existing component as a style reference: [PASTE OR DESCRIBE A REFERENCE COMPONENT]. The component should be: fully typed in TypeScript, accessible (keyboard navigable, correct ARIA labels), and handle empty, loading, and error states.

I need to integrate [API NAME] into my [TECH STACK] project. The API is used for [DESCRIBE: PAYMENT PROCESSING, EMAIL SENDING, MAPS, AI, ANALYTICS, ETC.]. My API key is stored in [DESCRIBE HOW: .ENV.LOCAL, ENVIRONMENT VARIABLES]. The integration needs to: [DESCRIBE WHAT API CALLS TO MAKE AND WHEN], handle API errors gracefully (rate limits, auth failures, timeouts), and be structured as a service layer so the API calls are not scattered through the codebase. Write the Cursor prompt that creates: the API client configuration, the service functions that wrap each API call with proper error handling, the types or interfaces for the API responses, and an example of calling the service from a component or route.

I have a bug in my [TECH STACK] project and need Cursor to fix it. The bug is: [DESCRIBE WHAT IS HAPPENING VS WHAT SHOULD HAPPEN]. The error message I see is: [PASTE THE EXACT ERROR]. The code that is throwing the error is in [FILE NAME]: [PASTE THE RELEVANT CODE SECTION]. I have already tried: [DESCRIBE WHAT YOU TRIED]. The context Cursor needs: [DESCRIBE ANY RELEVANT STATE, PROPS, OR DATA THAT ARE INVOLVED]. Write a debugging prompt that gives Cursor everything it needs to diagnose the root cause rather than guessing, and produces a fix rather than a suggestion to "try this."

I have a TypeScript error that is blocking my build. The error is: [PASTE FULL ERROR MESSAGE INCLUDING FILE AND LINE NUMBER]. The code at that location is: [PASTE THE RELEVANT CODE]. The expected type based on how this is being used is: [DESCRIBE WHAT THE TYPE SHOULD BE]. I do not want to fix this with "any" type or a type assertion unless it is genuinely the correct approach. Write a Cursor prompt that: diagnoses whether this is a type definition error, a missing type annotation, an incorrect assumption about the data shape, or a genuine type incompatibility, and produces the correct fix with an explanation of why the error occurred so I understand it and avoid the same mistake.

My API call or data fetch is not working correctly. The call is to [DESCRIBE THE ENDPOINT OR OPERATION]. The expected response is [DESCRIBE]. What I am actually getting is [DESCRIBE: ERROR, EMPTY RESPONSE, WRONG DATA SHAPE, ETC.]. The code making the call is: [PASTE]. The network tab shows: [DESCRIBE WHAT YOU SEE IN BROWSER DEVTOOLS OR SERVER LOGS IF AVAILABLE]. Write a Cursor debug prompt that: checks the request configuration (URL, headers, auth, body format), verifies the response handling (parsing, error catching, loading states), and identifies whether the issue is on the client side, the server side, or the API itself. Produce the corrected code and a quick test I can run to verify the fix.

My [TECH STACK] app has a performance problem: [DESCRIBE THE SYMPTOM: SLOW PAGE LOAD, UNNECESSARY RE-RENDERS, SLOW DATABASE QUERY, HIGH MEMORY USAGE, ETC.]. The issue appears to be in: [DESCRIBE WHICH PART OF THE APP]. The relevant code is: [PASTE]. Write a Cursor prompt that: profiles the performance issue methodically (what is causing the slowdown?), identifies the specific optimization to apply (memoization, lazy loading, query optimization, caching, etc.), implements the fix without introducing new bugs, and includes a way to verify that the fix actually improved performance (a before/after metric or a test).

Cursor built this function/component for me: [PASTE THE CODE]. I want to write tests for it to make sure it works correctly and does not break when I make future changes. My testing setup is [DESCRIBE: JEST, VITEST, PLAYWRIGHT, CYPRESS, ETC.]. Write the tests that: cover the happy path (the function works correctly with valid input), cover edge cases (empty input, null values, maximum values, unexpected types), cover error cases (what should happen when the function receives invalid input or an external dependency fails), and are structured so I can run them in CI and catch regressions before they reach production. Write the complete test file, not just examples.

I have a working vibe-coded app built with [TECH STACK] and I want to prepare it for production deployment. The app currently has these known issues or gaps: [DESCRIBE: NO ERROR HANDLING, HARDCODED VALUES, NO AUTH, ETC.]. Go through a production readiness checklist with Cursor and for each item, produce the code or configuration to address it: (1) environment variables: move all hardcoded values to .env, (2) error handling: add try/catch and error boundaries where missing, (3) input validation: add validation for all user inputs and API inputs, (4) security: review for common vulnerabilities (XSS, SQL injection, exposed API keys), (5) logging: add basic logging for errors and critical paths, (6) performance: identify any obviously slow operations.

I am ready to deploy my [NEXT.JS / REACT / OTHER FRAMEWORK] app to Vercel. The app was built with Cursor and uses [DESCRIBE KEY DEPENDENCIES: DATABASE, AUTH, EXTERNAL APIS]. Write the deployment checklist and Cursor prompts for: (1) setting up the Vercel project and connecting the repository, (2) configuring environment variables in Vercel that match my local .env.local, (3) checking the build configuration (next.config.js, vercel.json if needed), (4) handling any database or API setup that needs to happen for production (migrations, production API keys), (5) setting up the production domain. Include the specific Vercel CLI commands and the Cursor prompt to fix any build errors that come up during the first deploy.

I want to add payments to my [TECH STACK] app using [STRIPE / LEMON SQUEEZY / PADDLE]. The payment flow should support: [DESCRIBE: ONE-TIME PURCHASE, SUBSCRIPTION, USAGE-BASED BILLING]. My app currently has: [DESCRIBE WHAT EXISTS: USER AUTH, A PRODUCT OR PLAN, ETC.]. Write the Cursor prompt series to build the payment integration: (1) install and configure the payment SDK, (2) create the product or price in the payment platform dashboard (include what to set up), (3) build the checkout flow that creates a payment session, (4) build the webhook handler that updates the user's status after payment, (5) add the paid feature gating so only paying users can access [PAID FEATURES]. Write each step as a specific Cursor prompt.

I want to add AI features to my existing [TECH STACK] app using [OPENAI / ANTHROPIC / GROQ / VERCEL AI SDK]. The AI feature I want to add is: [DESCRIBE: CHAT ASSISTANT, CONTENT GENERATION, IMAGE ANALYSIS, CODE GENERATION, ETC.]. My app currently does: [DESCRIBE]. Write the Cursor prompts to add the AI feature: (1) set up the AI SDK and model configuration with the API key from environment variables, (2) create the API route or server action that calls the AI, (3) build the streaming response handler if the feature streams output to the user, (4) add the UI component that shows the AI output, (5) handle rate limiting and error cases. The feature should work correctly and handle the case where the AI API is down or returns an error.

I built an app using Cursor and vibe coding and now need to write documentation so I (or another developer) can understand and maintain it in the future. The app is [DESCRIBE]. The key files and their purpose are [LIST MAIN FILES]. Write a Cursor prompt that generates: a README.md with project overview, setup instructions, and key architectural decisions, inline comments for the 5 most complex or non-obvious sections of code, a CONTRIBUTING.md with how to add new features following the existing patterns, and a list of the known issues or TODOs that need attention before this could be called fully production-ready. The goal is documentation that makes the codebase understandable without requiring the original builder to explain it.