// Instead of manually writing authentication logic, prompt Cursor:
// "Create a Next.js API route for user authentication with JWT tokens, input validation, and error handling"

// Cursor generates complete implementation:
import { NextResponse } from 'next/server';
import { z } from 'zod';
import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';
import { db } from '@/lib/db';
const loginSchema = z.object({
  email: z.string().email(),
  password: z.string().min(8)
});
export async function POST(request: Request) {
  try {
    const body = await request.json();
    const { email, password } = loginSchema.parse(body);
    const user = await db.user.findUnique({ where: { email } });
    if (!user) {
      return NextResponse.json(
        { error: 'Invalid credentials' },
        { status: 401 }
      );
    }
    const validPassword = await bcrypt.compare(password, user.passwordHash);
    if (!validPassword) {
      return NextResponse.json(
        { error: 'Invalid credentials' },
        { status: 401 }
      );
    }
    const token = jwt.sign(
      { userId: user.id, email: user.email },
      process.env.JWT_SECRET!,
      { expiresIn: '7d' }
    );
    return NextResponse.json({ token, user: { id: user.id, email: user.email } });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Invalid input', details: error.errors },
        { status: 400 }
      );
    }
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}

// Type comment describing what you want
// function to calculate compound interest over time

// Copilot suggests complete implementation:
function calculateCompoundInterest(
  principal: number,
  rate: number,
  years: number,
  compoundingsPerYear: number = 12
): number {
  return principal * Math.pow(
    1 + rate / compoundingsPerYear,
    compoundingsPerYear * years
  );
}

1. Push code to GitHub
git add .
git commit -m "Add new feature"
git push origin main

2. Vercel automatically:
- Detects changes
- Runs build process
- Deploys to production CDN
- Invalidates cache
- Provides deployment URL
Total time: 2-3 minutes

railway.toml
[build]
builder = "NIXPACKS"

[deploy]
startCommand = "npm start"
healthcheckPath = "/health"
[[services]]
name = "api"
source = "."
[[services]]
name = "postgres"
image = "postgres:15"

import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);
// Database query
const { data: posts } = await supabase
  .from('posts')
  .select('*')
  .order('created_at', { ascending: false });
// Real-time subscription
const subscription = supabase
  .channel('posts')
  .on('postgres_changes', {
    event: '*',
    schema: 'public',
    table: 'posts'
  }, (payload) => {
    console.log('Database change:', payload);
  })
  .subscribe();
// Authentication
const { data, error } = await supabase.auth.signUp({
  email: 'user@example.com',
  password: 'securepassword123'
});

import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
// Create checkout session
const session = await stripe.checkout.sessions.create({
  payment_method_types: ['card'],
  line_items: [{
    price: 'price_1234567890',
    quantity: 1
  }],
  mode: 'subscription',
  success_url: 'https://yoursite.com/success',
  cancel_url: 'https://yoursite.com/cancel'
});

import { ClerkProvider, SignIn, SignUp, UserButton } from '@clerk/nextjs';

function App({ Component, pageProps }: AppProps) {
  return (
    
      
    
  );
}
// Use anywhere in app
function Header() {
  return (
    

       {/* Complete user menu */}
    
  );
}

import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);
await resend.emails.send({
  from: 'noreply@yourapp.com',
  to: 'user@example.com',
  subject: 'Welcome to Our App',
  react: WelcomeEmail({ userName: 'John' })
});

app/
├── (auth)/
│   ├── login/page.tsx
│   └── signup/page.tsx
├── (dashboard)/
│   ├── page.tsx
│   ├── settings/page.tsx
│   └── analytics/page.tsx
├── api/
│   ├── auth/route.ts
│   ├── posts/route.ts
│   └── analytics/route.ts
├── layout.tsx
└── page.tsx
lib/
├── db.ts              # Database client
├── auth.ts            # Auth utilities
└── email.ts           # Email utilities

import { pgTable, serial, text, timestamp, boolean } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: text('email').notNull().unique(),
  passwordHash: text('password_hash').notNull(),
  emailVerified: boolean('email_verified').default(false),
  createdAt: timestamp('created_at').defaultNow()
});
export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  userId: serial('user_id').references(() => users.id),
  title: text('title').notNull(),
  content: text('content').notNull(),
  published: boolean('published').default(false),
  createdAt: timestamp('created_at').defaultNow()
});

import { db } from './db';
import { users } from './schema';

// Fully typed query results
const allUsers = await db.select().from(users);
// allUsers type: { id: number; email: string; passwordHash: string; ... }[]
// Type-safe inserts
await db.insert(users).values({
  email: 'user@example.com',
  passwordHash: hashedPassword
  // TypeScript errors if required fields missing
});

model User {
  id            Int       @id @default(autoincrement())
  email         String    @unique
  passwordHash  String
  emailVerified Boolean   @default(false)
  posts         Post[]
  createdAt     DateTime  @default(now())
}

model Post {
  id        Int      @id @default(autoincrement())
  userId    Int
  user      User     @relation(fields: [userId], references: [id])
  title     String
  content   String
  published Boolean  @default(false)
  createdAt DateTime @default(now())
}

Generate migration from schema changes
npx prisma migrate dev --name add_user_posts

Prisma automatically creates SQL migration and applies it

import { initTRPC } from '@trpc/server';
import { z } from 'zod';

const t = initTRPC.create();
export const appRouter = t.router({
  getPost: t.procedure
    .input(z.object({ id: z.number() }))
    .query(async ({ input }) => {
      return await db.query.posts.findFirst({
        where: (posts, { eq }) => eq(posts.id, input.id)
      });
    }),
  createPost: t.procedure
    .input(z.object({
      title: z.string(),
      content: z.string()
    }))
    .mutation(async ({ input }) => {
      return await db.insert(posts).values(input);
    })
});
export type AppRouter = typeof appRouter;

import { createTRPCReact } from '@trpc/react-query';
import type { AppRouter } from './server';

const trpc = createTRPCReact();
function PostComponent() {
  // Fully typed, autocomplete works
  const { data: post } = trpc.getPost.useQuery({ id: 1 });
  const createPost = trpc.createPost.useMutation();
  return (
    

      
{post?.title}
       createPost.mutate({
        title: 'New Post',
        content: 'Content here'
      })}>
        Create
      
    
  );
}

Create Next.js project with TypeScript
npx create-next-app@latest my-startup --typescript --tailwind --app

cd my-startup
Install core dependencies
npm install @supabase/supabase-js @clerk/nextjs stripe @trpc/server @trpc/client @trpc/react-query drizzle-orm
Setup Drizzle
npm install -D drizzle-kit
npx drizzle-kit init
Setup Vercel
vercel link

// drizzle/schema.ts
export const users = pgTable('users', {
  id: text('id').primaryKey(),
  email: text('email').notNull().unique(),
  createdAt: timestamp('created_at').defaultNow()
});

export const subscriptions = pgTable('subscriptions', {
  id: serial('id').primaryKey(),
  userId: text('user_id').references(() => users.id),
  stripeSubscriptionId: text('stripe_subscription_id'),
  status: text('status'),
  planId: text('plan_id'),
  currentPeriodEnd: timestamp('current_period_end')
});
// Run migrations
npx drizzle-kit generate:pg
npx drizzle-kit push:pg

// app/layout.tsx
import { ClerkProvider } from '@clerk/nextjs';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    
      
        {children}
      
    
  );
}
// Protect routes
import { auth } from '@clerk/nextjs';
export default async function DashboardPage() {
  const { userId } = auth();
  if (!userId) {
    redirect('/login');
  }
  // Page content
}

// Prompt Cursor: "Create a CRUD interface for blog posts with:
// - List view with pagination
// - Create/edit form with validation
// - Delete with confirmation
// - Published/draft toggle
// Use shadcn/ui components and tRPC"
// Cursor generates complete implementation:
// Server tRPC router
export const postsRouter = t.router({
  list: t.procedure
    .input(z.object({
      page: z.number().default(1),
      perPage: z.number().default(10)
    }))
    .query(async ({ input }) => {
      const { page, perPage } = input;
      const offset = (page - 1) * perPage;
      const [posts, total] = await Promise.all([
        db.query.posts.findMany({
          limit: perPage,
          offset,
          orderBy: (posts, { desc }) => desc(posts.createdAt)
        }),
        db.select({ count: count() }).from(posts)
      ]);
      return {
        posts,
        pagination: {
          page,
          perPage,
          total: total[0].count,
          totalPages: Math.ceil(total[0].count / perPage)
        }
      };
    }),
  create: t.procedure
    .input(z.object({
      title: z.string().min(1),
      content: z.string().min(1),
      published: z.boolean().default(false)
    }))
    .mutation(async ({ input, ctx }) => {
      return await db.insert(posts).values({
        ...input,
        userId: ctx.userId
      });
    }),
  // ... update and delete procedures
});
// Client component (auto-generated by Cursor)
function PostsManager() {
  const [page, setPage] = useState(1);
  const { data } = trpc.posts.list.useQuery({ page });
  const createPost = trpc.posts.create.useMutation({
    onSuccess: () => {
      queryClient.invalidateQueries(['posts']);
    }
  });
  return (
    

      
      
      
    
  );
}

// app/api/create-checkout/route.ts
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
export async function POST(req: Request) {
  const { priceId, userId } = await req.json();
  const session = await stripe.checkout.sessions.create({
    customer_email: user.email,
    client_reference_id: userId,
    payment_method_types: ['card'],
    line_items: [{
      price: priceId,
      quantity: 1
    }],
    mode: 'subscription',
    success_url: ${process.env.NEXT_PUBLIC_URL}/dashboard?success=true,
    cancel_url: ${process.env.NEXT_PUBLIC_URL}/pricing?canceled=true,
    subscription_data: {
      metadata: { userId }
    }
  });
  return Response.json({ sessionId: session.id });
}
// Webhook handler
export async function POST(req: Request) {
  const body = await req.text();
  const sig = req.headers.get('stripe-signature')!;
  const event = stripe.webhooks.constructEvent(
    body,
    sig,
    process.env.STRIPE_WEBHOOK_SECRET!
  );
  switch (event.type) {
    case 'checkout.session.completed':
      // Update user subscription in database
      break;
    case 'customer.subscription.deleted':
      // Handle cancellation
      break;
  }
  return Response.json({ received: true });
}

import { Resend } from 'resend';
import { WelcomeEmail } from '@/emails/Welcome';

const resend = new Resend(process.env.RESEND_API_KEY);
export async function sendWelcomeEmail(user: { email: string; name: string }) {
  await resend.emails.send({
    from: 'team@yourstartup.com',
    to: user.email,
    subject: 'Welcome to Your Startup!',
    react: WelcomeEmail({ userName: user.name })
  });
}

// lib/analytics.ts
import { track } from '@vercel/analytics';

export function trackEvent(event: string, properties?: Record) {
  track(event, properties);
}
// Usage in components
function SignupButton() {
  return (
     {
      trackEvent('signup_clicked', {
        location: 'homepage',
        plan: 'pro'
      });
    }}>
      Sign Up
    
  );
}

// app/posts/[id]/page.tsx
export const revalidate = 3600; // Revalidate every hour

export async function generateStaticParams() {
  const posts = await db.query.posts.findMany({
    where: (posts, { eq }) => eq(posts.published, true)
  });
  return posts.map(post => ({
    id: post.id.toString()
  }));
}
export default async function PostPage({ params }: { params: { id: string } }) {
  const post = await db.query.posts.findFirst({
    where: (posts, { eq }) => eq(posts.id, parseInt(params.id))
  });
  return ;
}

import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL);
// Rate limiting
export async function checkRateLimit(userId: string): Promise {
  const key = rate_limit:${userId};
  const current = await redis.incr(key);
  if (current === 1) {
    await redis.expire(key, 60); // 60 second window
  }
  return current <= 100; // 100 requests per minute
}

// app/layout.tsx
import { Analytics } from '@vercel/analytics/react';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    
      
        {children}
        
      
    
  );
}

import * as Sentry from '@sentry/nextjs';

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
  tracesSampleRate: 1.0
});
// Automatic error capture
try {
  await riskyOperation();
} catch (error) {
  Sentry.captureException(error);
  throw error;
}

// Over-engineered from day one
class AbstractPaymentProcessorFactory {
  createProcessor(type: string): PaymentProcessor {
    // Complex abstraction no one asked for
  }
}

// Simple, direct implementation
async function processPayment(amount: number, customerId: string) {
  return await stripe.charges.create({
    amount,
    customer: customerId
  });
}

// Unnecessary caching layer from day one
const cache = new Map();
async function getData(id: string) {
  if (cache.has(id)) return cache.get(id);
  const data = await db.query.data.findFirst({
    where: (data, { eq }) => eq(data.id, id)
  });
  cache.set(id, data);
  return data;
}

// Simple query until metrics show it's slow
async function getData(id: string) {
  return await db.query.data.findFirst({
    where: (data, { eq }) => eq(data.id, id)
  });
}

// Add caching ONLY when monitoring shows this endpoint is slow

// Direct Supabase calls everywhere
const { data } = await supabase.from('users').select('*');

// lib/db.ts - abstraction layer
export async function getUsers() {
  // Supabase today, but can swap providers easily
  const { data } = await supabase.from('users').select('*');
  return data;
}

// Usage in app
import { getUsers } from '@/lib/db';
const users = await getUsers();