The Best Cursor IDE Prompts for Building a SaaS MVP

Cursor is an AI-powered code editor with multiple AI modes: Agent (⌘I) for complex tasks, Inline Edit (⌘K) for quick changes, Tab for autocomplete, and Chat for conversations. This prompt library gives you production-ready examples optimized for Cursor Agent's autonomous capabilities.

Agent (⌘I)

Complex tasks across multiple files. Use for building complete features.

Inline Edit (⌘K)

Quick edits to selected code. Fast refactoring and small changes.

Tab

Multi-line autocomplete. Predicts next edits based on context.

Why These Prompts Work with Cursor

Specific & Actionable

Each prompt specifies exact files to create, components to build, and functions to implement. Cursor Composer works best with clear, specific instructions.

Uses .cursorrules Context

Includes a comprehensive .cursorrules file that provides context for all prompts, ensuring consistent code style and best practices.

Feature-by-Feature Approach

Break down MVP into discrete features (database, auth, payments) that Cursor can tackle one at a time with Agent mode.

Always Review Changes

Prompts emphasize using Cursor's diff view to review changes. Treat AI as a pair programmer - always verify before accepting.

What You'll Build with These Prompts

Complete database schema with Drizzle ORM
Server Actions for all CRUD operations
React components with shadcn UI
Stripe subscription integration
Production-ready deployment to Vercel

Step 1: Add .cursorrules File

Create this file in your project root. Cursor will automatically use it as context for ALL prompts, ensuring consistent code quality.

.cursorrules

Project-wide rules for SaaS MVP development

# .cursorrules - SaaS MVP Development Guide

You are an expert full-stack developer building a production-ready SaaS MVP.

## Tech Stack
- Next.js 15 (App Router)
- TypeScript (strict mode)
- Tailwind CSS + Shadcn UI
- Supabase (PostgreSQL)
- Drizzle ORM
- Kinde Auth
- Stripe Payments
- Resend Email

## Code Standards

### TypeScript
- Use strict mode
- Functional components with hooks
- Proper type annotations (no 'any')
- Interface over type for object shapes

### React/Next.js
- Server components by default
- "use client" only when needed (state, effects, event handlers)
- Server Actions in app/actions/ for mutations
- Call revalidatePath after mutations

### Database
- Use Drizzle ORM for all queries
- snake_case for DB columns, camelCase for TypeScript
- Filter ALL queries by userId for security
- Proper foreign keys and indexes

### Security
- Check auth with getKindeServerSession in every server action
- Validate all inputs with Zod
- Never expose secrets in client code
- Use environment variables

### UI/UX
- Mobile-first responsive design
- Loading states for all async operations
- Error handling with helpful messages
- Use shadcn UI components (Dialog, Card, Button, Input, etc.)
- Professional look (like Stripe or Linear)

## File Structure
- Server Actions: app/actions/[feature].ts
- Components: components/[ComponentName].tsx
- Pages: app/[route]/page.tsx
- Database: db/schema.ts
- Emails: emails/[EmailName].tsx

## Best Practices
- Keep components under 200 lines
- CRUD operations in server actions
- One feature per file
- Always add error boundaries
- Mobile responsive by default

When I ask you to build a feature, create all necessary files following these standards.

Step 2: Complete SaaS MVP Prompt (Recommended)

This comprehensive prompt walks Cursor Agent through building your entire SaaS step-by-step. Open Agent (⌘I), enable auto-run, and paste this prompt.

Complete SaaS MVP Builder

Step-by-step guide for Cursor Agent to build your entire MVP

Build a complete, production-ready SaaS MVP called [YOUR_PRODUCT_NAME].

## Product Overview
**What it does**: [BRIEF_DESCRIPTION]
**Core problem**: [MAIN_PAIN_POINT]
**Target users**: [WHO_USES_IT]
**Key features**: [LIST_2_4_CORE_FEATURES]

Follow these steps to build the complete MVP:

## Step 1: Database Schema
Create **db/schema.ts** with Drizzle ORM:
- Standard users table: id (varchar 255), email, firstName, lastName, role, createdAt, stripeCustomerId, stripeSubscriptionId, subscriptionStatus, subscriptionEndsAt
- 2-4 custom tables for [YOUR_PRODUCT_NAME]'s core features
- Use snake_case for columns, camelCase for TypeScript
- Add foreign keys to users.id and proper indexes
- Generate SQL I can run in Supabase (don't use drizzle-kit push)

## Step 2: Customize Theme & Branding
**app/globals.css**:
- Add 2 Google Fonts that match [YOUR_PRODUCT_NAME] personality
- Update CSS variables for primary, secondary, accent colors
- Match brand personality (warm/cool/professional)

**components/LandingPageClient.tsx**:
- Update hero headline for [YOUR_PRODUCT_NAME]
- Change feature card copy
- Add relevant Lucide icons

## Step 3: Build Core Features
For each main feature of [YOUR_PRODUCT_NAME], create:

**app/actions/[feature].ts**:
- create[Feature], get[Features], update[Feature], delete[Feature]
- Authentication with getKindeServerSession
- Zod validation, revalidatePath after mutations
- Filter all queries by userId

**components/Create[Feature]Dialog.tsx**:
- shadcn Dialog with form
- Loading states, error handling
- "use client"

**components/[Feature]List.tsx**:
- Display in Cards with edit/delete
- Empty state
- "use client"

**components/[Feature]Stats.tsx**:
- Summary statistics in Cards

## Step 4: Build Dashboard
**app/dashboard/page.tsx**:
- Import all feature components
- Show stats at top
- Onboarding for new users
- Use shadcn Tabs for different views
- Mobile responsive layout

## Step 5: Add Subscription Plans
**lib/subscription.ts**:
- isPlusUser(user), canAccess[Feature](user)
- Free plan: [LIMITS - e.g., 5 items max]
- Plus plan: $49/year, unlimited

**components/UpgradePrompt.tsx**:
- Explain Plus benefits
- Upgrade CTA

**app/pricing/page.tsx**:
- Pricing comparison table
- Stripe checkout button

## Step 6: Stripe Integration
**app/api/create-checkout-session/route.ts**:
- Create Stripe checkout session

**app/api/webhooks/stripe/route.ts**:
- checkout.session.completed → upgrade user
- customer.subscription.updated → handle renewals
- customer.subscription.deleted → downgrade
- Verify webhook signatures

**Enforce limits**:
- Check subscription in server actions
- Show UpgradePrompt when hitting limits

## Step 7: Email Setup
**emails/WelcomeEmail.tsx**:
- Welcome email with @react-email/components

**emails/SubscriptionConfirmation.tsx**:
- Thank you for upgrading

**lib/email.ts**:
- sendWelcomeEmail, sendSubscriptionConfirmation

Trigger emails in webhooks and auth callbacks.

## Step 8: Production Prep
- Run `npm run build` and fix ALL errors
- Create .env.example with all required vars
- Verify no hardcoded secrets
- Test auth flow, database queries, Stripe test mode
- Keep git clean - commit before major changes

## Success Criteria
When done, I should have:
- Working app at localhost:3000
- Complete auth flow (signup, login, logout)
- All CRUD operations functional
- Stripe checkout with test cards
- Free users hit plan limits
- Professional UI on mobile and desktop
- Zero build errors

Work through each step methodically. After each step, show me what you created and ask if I want to proceed to the next step.

💡 Best Way to Use This Prompt

This prompt is designed for Cursor Agent's iterative workflow. After each step, Agent will show you what it created and wait for confirmation before proceeding. This gives you control while maintaining momentum.

• Review each step's output before proceeding
• Ask Agent to modify if something isn't quite right
• Commit to git after each major step
• Use checkpoints before risky operations

Alternative: Feature-by-Feature Prompts

Prefer more control? Use these individual prompts to build one feature at a time. Great if you want to mix AI assistance with manual coding.

1. Database Schema Design

Create your database schema with Drizzle ORM

I need to design the database schema for my SaaS MVP called [YOUR_PRODUCT_NAME].

**Product**: [BRIEF_DESCRIPTION]
**Core features**: [LIST_2_4_FEATURES]

Using Drizzle ORM, create:

1. **db/schema.ts** with:
   - Standard users table (id varchar 255, email, firstName, lastName, role, createdAt, stripeCustomerId, stripeSubscriptionId, subscriptionStatus, subscriptionEndsAt)
   - 2-4 custom tables for the product's core features
   - Proper foreign keys to users.id
   - Indexes on frequently queried fields
   - snake_case columns, camelCase TypeScript

2. **SQL file** I can run in Supabase (don't use drizzle-kit push)

Make the schema simple but production-ready. Include relationships and constraints.

2. Theme & Branding

Customize colors, fonts, and landing page

Customize the theme and branding for [YOUR_PRODUCT_NAME].

**Brand personality**: [warm/cool/professional/playful/etc.]
**Target users**: [WHO_USES_IT]

1. **Choose 2 Google Fonts** that match the brand
2. **Update app/globals.css**:
   - Add @import for fonts at the very top (before @tailwind)
   - Update CSS variables: --primary, --primary-foreground, --secondary, --accent, --ring, --border
   - Choose colors that match the product personality
   - Make sure CTA buttons use the primary color

3. **Update components/LandingPageClient.tsx**:
   - Change hero headline to something attention-grabbing for [YOUR_PRODUCT_NAME]
   - Update feature card copy
   - Add relevant Lucide React icons to each feature
   - Make it compelling and specific to this product

Make it look professional (like Stripe or Linear) with the custom brand colors applied throughout.

3. Build a Complete Feature

Server actions + React components + dashboard integration

Build a complete [FEATURE_NAME] feature for my SaaS.

**What it does**: [DESCRIPTION]
**User flow**: [STEP_BY_STEP_FLOW]

Create these files:

1. **app/actions/[feature].ts** - Server actions:
   - create[Feature], get[Features], update[Feature], delete[Feature]
   - Authentication with getKindeServerSession
   - Zod validation
   - revalidatePath after mutations
   - Filter all queries by userId

2. **components/Create[Feature]Dialog.tsx**:
   - Dialog with form (shadcn Dialog, Input, Textarea, Button)
   - Call server action on submit
   - Loading states, error handling
   - "use client"

3. **components/[Feature]List.tsx**:
   - Display all items in Cards
   - Edit/delete buttons
   - Empty state
   - "use client"

4. **components/[Feature]Stats.tsx**:
   - Summary statistics
   - Use shadcn Card
   - "use client" if needed

5. **Update app/dashboard/page.tsx**:
   - Import and use all components
   - Clean layout with stats at top
   - Tabs if needed (shadcn Tabs)

Make it production-ready with proper error handling and mobile responsive.

4. Stripe Payments

Complete subscription integration with webhooks

Add Stripe subscription payments to my SaaS.

**Plans**:
- Free: [DEFINE_LIMITS - e.g., 5 items max]
- Plus: $49/year, unlimited

Create:

1. **lib/subscription.ts**:
   - isPlusUser(user), isFreePlan(user)
   - canAccess[Feature](user)
   - Plan limit helpers

2. **components/UpgradePrompt.tsx**:
   - Modal explaining Plus benefits
   - "Upgrade to Plus" CTA button

3. **app/pricing/page.tsx**:
   - Pricing table (Free vs Plus)
   - Stripe checkout button

4. **app/api/create-checkout-session/route.ts**:
   - Create Stripe checkout session
   - Return checkout URL

5. **app/api/webhooks/stripe/route.ts**:
   - checkout.session.completed → upgrade user
   - customer.subscription.updated → handle renewals
   - customer.subscription.deleted → downgrade to free

6. **Enforce limits** in server actions:
   - Check subscription status before operations
   - Return error if free user hits limit
   - Show UpgradePrompt

Include webhook signature verification and proper error handling.

5. Production Deployment

Prepare for deployment to Vercel

Prepare my SaaS for production deployment to Vercel.

1. **FIRST: Fix build errors**:
   - Run `npm run build`
   - Fix ALL TypeScript errors
   - Fix ALL ESLint issues
   - Don't proceed until build succeeds

2. **Create .env.example**:
   - List all required env vars (without values)
   - Add comments explaining each

3. **Update README.md**:
   - Setup instructions
   - Environment variables
   - Deployment guide

4. **Verify files**:
   - .gitignore includes .env
   - No hardcoded secrets
   - All imports work

5. **Test locally**:
   - Authentication flow works
   - Database queries work
   - Stripe test mode works

Give me a deployment checklist when done.

How to Use These Prompts in Cursor

1. Create .cursorrules file in your project root
2. Open Cursor Agent with ⌘I (Mac) or Ctrl+I (Windows)
3. Enable Agent mode tools:
- • Auto-run: Let Agent execute terminal commands automatically
- • Auto-apply: Apply code edits without confirmation
- • Codebase search: Agent uses semantic search to find relevant code
4. Copy a prompt, replace placeholders with your product details
5. Use @ symbols to reference files: @filename.ts
6. Let Agent work - it will search, edit, and run commands autonomously
7. Review changes in diff view before accepting (⌘Enter to accept all)
8. Use checkpoints to save state before major changes
9. Repeat with next prompt to build feature-by-feature

Pro Tips for Better Results

Keep git clean: Commit before each major change. Easy to revert if needed.
Close unused tabs: Agent uses open tabs as context. Close what you don't need.
Use checkpoints: Save snapshots before risky changes (right-click in chat).
Reference docs: Add documentation to codebase index for better context.
Monitor errors: Keep TypeScript running in terminal to catch issues early.
Iterate: If output isn't perfect, ask Agent to refine it in the same chat.