Vibe Coding Cheat Sheet — The Complete Reference

Context: Next.js 15 app with Prisma and PostgreSQL.
The user model already exists.

Requirements: Create a pagination utility that works
with any Prisma model. It should accept page number,
page size, and an optional filter. It should return
the data, total count, total pages, and current page.

Input: { model: PrismaModel, page: number,
pageSize: number, where?: object }
Output: { data: T[], total: number, totalPages: number,
page: number, pageSize: number }

Style: TypeScript with generics. No classes — use
a plain function. Match the existing utility pattern
in lib/utils.ts.

Priority: Type safety first. The return type should
be fully typed based on the Prisma model.

Write a specification for [feature]. Do not write code yet.
Include: requirements, API design, data model, edge cases.

Implement only [Step N] from the specification.
Do not change anything from the previous steps.

Review the code you just generated for [specific concern].
Fix any issues you find.

Write tests for [feature] first. Then implement the
code to make the tests pass.

Explain how [algorithm/pattern] works. Then implement
it for our use case: [description].

Implement [feature] using only [specific libraries].
Do not add any new dependencies.
Follow the pattern in [existing file].

Add comprehensive error handling to [function/module].
Handle: [list specific error cases].
Each error should have a specific error code and message.

Refactor [code] to [goal]. Do not change the external
API or behavior. Show me the changes before applying them.

Review [file] for security vulnerabilities.
Check for: injection, auth bypass, data exposure,
rate limiting gaps. List each issue with severity.

Migrate [code] from [old pattern] to [new pattern].
Keep backward compatibility. Add deprecation warnings
for old usage. Include a migration guide in comments.

# Project Name

## Overview
Brief description of what this project does.

## Tech Stack
- Language: TypeScript 5.6
- Framework: Next.js 15 (App Router)
- Database: PostgreSQL with Prisma 6.2
- Testing: Vitest + Testing Library
- Styling: Tailwind CSS v4

## Project Structure
- app/ — Next.js pages and layouts
- lib/ — Shared utilities and configurations
- components/ — Reusable UI components
- prisma/ — Database schema and migrations

## Coding Conventions
- Use Server Components by default
- Use Server Actions for mutations
- Zod for all input validation
- Conventional commits with Co-authored-by trailers
- No default exports (except pages)
- Prefer const arrow functions

## Commands
- Dev: npm run dev
- Test: npm test
- Build: npm run build
- Lint: npm run lint

## Important Rules
- Never hardcode secrets — use environment variables
- Always validate user input with Zod
- Always check resource ownership before mutations
- Keep API response shapes consistent

You are an expert TypeScript developer working on a
Next.js 15 application.

Rules:
- Use TypeScript strict mode
- Prefer Server Components over Client Components
- Use Tailwind CSS for styling — no CSS modules
- Follow the existing file structure and naming
- Import from @/ path alias
- Use Zod for validation, not manual checks
- Error messages should be user-friendly
- Write tests with Vitest

When writing Compose components:
- Keep components under 100 lines
- Extract reusable logic to custom hooks
- Use Shadcn/ui components from components/ui/

When writing API routes:
- Validate all inputs with Zod schemas
- Return consistent error shapes
- Use proper HTTP status codes
- Always authenticate protected routes

This is a TypeScript project using Next.js 15.

Preferences:
- Prefer arrow functions with explicit return types
- Use const assertions where appropriate
- Import types with the type keyword
- Prefer early returns over nested conditionals
- Use template literals over string concatenation

Testing:
- Use Vitest, not Jest
- Use Testing Library, not Enzyme
- Prefer integration tests over unit tests
- Mock external services, not internal modules

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@localhost:5432/mydb"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token"
      }
    }
  }
}

# AI generates code → review → fix → commit
git add [specific files]
git commit -m "feat(scope): description

Co-authored-by: Claude <noreply@anthropic.com>"

# Count AI-assisted commits
git log --grep="Co-authored-by: Claude" --oneline | wc -l

# Compare AI vs human commits
git log --oneline | wc -l  # Total

## Summary
What and why.

## AI Tools Used
- Claude Code: [what it generated]
- Manual: [what you wrote/fixed]

## Testing
- [ ] Tests pass
- [ ] Manual testing done

Monthly hours saved x hourly rate = Value
Value - Tool costs = Monthly ROI