Snippet Management

You are building a new React component and you type useState for the fifth time today. Tab completion fills in the hook, but you still have to manually add the TypeScript types, the initial value, and the pattern for handling loading and error states. Every component starts with the same 15-line boilerplate, and every time you write it slightly differently. Meanwhile, your teammate structures their components a different way entirely.

Snippets solve the boilerplate problem, but traditional VS Code snippets are static templates that do not adapt to your project’s patterns. When you combine snippets with Cursor’s AI, you get dynamic code generation that follows your conventions automatically.

What You’ll Walk Away With

• A snippet strategy that combines VS Code snippets with Cursor rules for maximum speed
• Copy-paste rules that turn common patterns into instant boilerplate
• Techniques for generating and managing project-specific snippets
• Workflow patterns for using snippets alongside AI-generated code

The Two-Layer Snippet Strategy

Layer 1: VS Code Snippets for Muscle Memory

Use traditional VS Code snippets for patterns you type dozens of times per day. These are instant (no AI round-trip) and deterministic (same output every time):

{
  "React Functional Component": {
    "prefix": "rfc",
    "scope": "typescriptreact",
    "body": [
      "interface ${1:Component}Props {",
      "  $2",
      "}",
      "",
      "export function ${1:Component}({ $3 }: ${1:Component}Props) {",
      "  $0",
      "  return (",
      "    <div>",
      "      ",
      "    </div>",
      "  )",
      "}"
    ]
  }
}

Store project-specific snippets in .vscode/project.code-snippets and check them into version control.

Layer 2: Cursor Rules for Smart Boilerplate

For patterns that need to adapt to context (the right imports, the right types, the right error handling for this specific project), use Cursor rules instead of static snippets:

Tip

Copy-paste rule for API route boilerplate (.cursor/rules/route-template.mdc):

---
description: Generate boilerplate for a new API route handler
alwaysApply: false
---

When I ask you to create a new route handler, generate this structure:

1. Import the required middleware from @src/middleware/
2. Import the Zod schema from @src/schemas/
3. Import the service from @src/services/
4. Create the handler with proper TypeScript types
5. Add validation, authentication, error handling
6. Follow the exact pattern in @src/routes/users.ts

This rule generates context-aware boilerplate, not static templates.

Tip

Copy-paste rule for component boilerplate:

Create .cursor/rules/component-template.mdc:

---
description: Create a new React component with project conventions
alwaysApply: false
---

When creating a new React component:
1. Define the Props interface above the component
2. Use named export (not default)
3. Import UI primitives from @src/components/ui/
4. Use the data fetching pattern from @src/hooks/use-fetch.ts
5. Handle loading, error, and empty states
6. Follow the structure in @src/components/UserProfile.tsx

Generating Snippets with AI

Let Cursor analyze your codebase and generate snippets based on your actual patterns:

Tip

Copy-paste prompt for snippet generation:

Analyze the patterns in @src/components/ and generate VS Code snippets for the 5 most common component patterns in this project.

Output as a JSON file suitable for .vscode/project.code-snippets. Include:
- The snippet prefix (short, memorable)
- Tab stops for customizable parts
- The boilerplate that is consistent across components
- A description for each snippet

Base the snippets on actual code in the project, not generic templates.

Snippet Workflows

The Quick Component Workflow

1. Type the snippet prefix (rfc for a React component)
2. Tab through the placeholders to set the component name and props
3. Press Cmd+K to fill in the component body with AI: “fetch user notifications and display them in a list. Render a loading skeleton while fetching, an error state with a retry button on failure, and an empty state when there are no notifications.”
4. Tab to accept the AI suggestion

This is exactly the boilerplate from the opening scenario: the rfc snippet drops in the typed shell instantly, and the Cmd+K instruction makes Cursor fill the loading, error, and empty states the same way every time — so the three states stop being something each teammate writes slightly differently. It combines the speed of snippets (instant boilerplate) with the intelligence of AI (context-aware implementation).

The Pattern Replication Workflow

When you need to create something that follows an existing pattern:

1. Open the file you want to replicate
2. Press Cmd+Shift+L to add it as context
3. Open a new file
4. Tell Agent: “Create a [new thing] following the exact pattern in the file I added as context”

This is effectively a “smart snippet” that adapts the template to your specific needs.

When This Breaks

Snippets conflict with Tab completion. If a VS Code snippet prefix conflicts with Cursor’s Tab suggestions, the snippet takes priority. Choose unique prefixes that do not overlap with common code tokens.

AI-generated boilerplate drifts from snippets. When your rules and snippets describe different patterns, developers get inconsistent output. Keep them aligned: when you update a snippet, update the corresponding rule.

Too many snippets slow down autocomplete. If you have 100+ snippets, the autocomplete dropdown becomes noisy. Prefix snippets by category (api-, comp-, test-) so you can type the category to filter.

Rules go stale when the reference file moves. A rule that points at @src/components/UserProfile.tsx silently degrades the day someone renames or relocates that file — the agent keeps generating against a path that no longer resolves. Anchor rules to a canonical example you intend to keep, and update the @-path whenever you refactor it. When in doubt, ask Cursor to “list every .cursor/rules/*.mdc file that references a path that no longer exists in the repo” so you can fix them in one pass.

What’s Next

• Context Patterns — Using existing files as living templates
• Prompt Templates — Reusable prompts that complement snippets
• Time Savers — More workflow optimizations that save daily time