> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getsnippets.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Access with AI Tools

> Use Quick Access to insert prompts and code in Cursor, Lovable, and other AI tools

## Overview

Quick Access shines brightest when paired with AI development tools. Whether you're building with Cursor, designing in Lovable, or prompting Claude, Quick Access gives you instant access to your best prompts and code snippets-right when you need them.

This guide shows you how to supercharge your AI workflow by combining Quick Access with popular AI tools.

## Why This Matters

AI tools are powerful, but they require good prompts. Quick Access ensures:

* **Consistency**: Use your best prompts every time, not recreate them from memory
* **Speed**: Insert complex prompts in seconds instead of minutes
* **Iteration**: Build a library of refined prompts that improve over time
* **Team Alignment**: Share proven prompts with your team through workspaces

## Quick Access + Lovable

Lovable is an AI website builder that turns prompts into production-ready websites. Quick Access makes it effortless to use your best prompts.

<iframe src="https://player.vimeo.com/video/1105235116?h=0&title=0&byline=0&portrait=0&autoplay=1&muted=1" width="100%" height="450" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen />

### How to Use with Lovable

#### 1. **Open Lovable's Prompt Box**

Navigate to Lovable and click into the prompt input field where you describe what you want to build.

#### 2. **Trigger Quick Access**

Press `Option + Space` (Mac) or `Ctrl + Space` (Windows/Linux) while your cursor is in the prompt box.

#### 3. **Find Your Prompt**

Search for your saved Lovable prompts:

* Type "lovable landing page"
* Or search by tag: "web-design"
* Or browse your Lovable folder

#### 4. **Insert and Build**

Press `Enter` to insert the prompt. Your detailed, tested prompt is now in Lovable's input, ready to generate your website.

### Example Lovable Prompts to Save

**Landing Page Template**

```markdown theme={null}
Create a modern SaaS landing page with:

- Hero section with gradient background
- Features section (3 columns)
- Pricing table (3 tiers)
- FAQ accordion
- CTA buttons with hover effects
- Mobile responsive
- Dark mode support
  Use Tailwind CSS and clean, professional design.
```

**Dashboard UI**

```markdown theme={null}
Build an analytics dashboard with:

- Sidebar navigation
- Top metrics cards showing KPIs
- Line charts for trends
- Data table with sorting/filtering
- Export functionality
- Real-time data updates
  Modern, glassmorphism design style.
```

Save these in Quick Access, and you'll never write them from scratch again.

## Quick Access + Cursor

Cursor is the AI-first code editor. Quick Access integrates seamlessly to give you instant access to code snippets and prompting templates.

<iframe src="https://player.vimeo.com/video/1105239672?h=0&title=0&byline=0&portrait=0&autoplay=1&muted=1" width="100%" height="450" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen />

### How to Use with Cursor

#### 1. **Open Cursor AI Chat**

Open Cursor's AI chat panel (`Cmd/Ctrl + L`) or inline prompt (`Cmd/Ctrl + P`).

#### 2. **Trigger Quick Access**

With your cursor in the prompt field, press `Option/Ctrl + Space`.

#### 3. **Insert Your Prompt**

Search for code generation prompts, debugging templates, or refactoring instructions.

#### 4. **Let Cursor Generate**

Your prompt is inserted, and Cursor's AI generates code based on your saved, tested instructions.

### Example Cursor Prompts to Save

**Code Review Prompt**

```markdown theme={null}
Review this code for:

1. Security vulnerabilities (SQL injection, XSS, etc.)
2. Performance bottlenecks
3. Code smells and anti-patterns
4. Missing error handling
5. Unclear variable names

Provide specific suggestions with code examples.
```

**Refactoring Prompt**

```typescript theme={null}
// Refactor this to:
// - Extract reusable functions
// - Add proper TypeScript types
// - Implement error handling
// - Add JSDoc comments
// - Follow clean code principles
```

**Test Generation**

```javascript theme={null}
Generate unit tests for this function:
- Test happy path scenarios
- Test edge cases and boundaries
- Test error conditions
- Use Jest and TypeScript
- Aim for 100% coverage
```

## Quick Access + ChatGPT / Claude

Use Quick Access with web-based AI tools like ChatGPT and Claude.

### How to Use

1. Open ChatGPT or Claude in your browser
2. Click into the message input field
3. Press `Option/Ctrl + Space` to open Quick Access
4. Search and insert your prompt

### Workflow Example

**Multi-Step Prompt Engineering**

Save each step as a separate snippet:

1. **Context Setup**

```markdown theme={null}
You are an expert backend engineer specializing in Node.js and PostgreSQL.
I'm building a REST API for an e-commerce platform.
```

2. **Task Definition**

```markdown theme={null}
Design a database schema for:

- Users and authentication
- Products and inventory
- Orders and payments
- Reviews and ratings
  Include relationships, indexes, and constraints.
```

3. **Output Format**

```markdown theme={null}
Provide:

1. SQL CREATE TABLE statements
2. ER diagram description
3. Index recommendations
4. Sample queries for common operations
```

Insert each snippet in sequence to build complex, structured prompts.

## Quick Access + VS Code

While Cursor is AI-native, VS Code with GitHub Copilot or other extensions also benefits from Quick Access.

### Use Cases

**Copilot Comments**

```javascript theme={null}
// Create a React component that:
// - Accepts a list of items as props
// - Implements virtual scrolling for performance
// - Includes search and filter functionality
// - Has keyboard navigation support
```

**Code Templates**

```typescript theme={null}
// Express.js API route template
import { Router, Request, Response } from 'express';

const router = Router();

router.get('/endpoint', async (req: Request, res: Response) => {
	try {
		// Implementation
		res.json({ success: true });
	} catch (error) {
		res.status(500).json({ error: error.message });
	}
});

export default router;
```

## Quick Access + Other AI Tools

Quick Access works with any application:

### Notion AI

* Open Notion → Quick Access → Insert writing prompts
* Use for documentation templates, meeting notes, project briefs

### Slack

* Quick Access your common responses
* Insert formatted messages and announcements
* Use emoji reactions and formatting

### Email Clients

* Gmail, Outlook, Superhuman
* Insert email templates, follow-ups, cold outreach

### Terminal

* Quick Access bash scripts and commands
* Insert Docker commands, Git workflows, deployment scripts

## Building Your AI Toolkit

Here's how to organize your Quick Access library for AI tools:

### Folder Structure

```
📁 AI Prompts
  📁 Cursor
    - Code Review Template
    - Refactoring Prompt
    - Test Generation
  📁 Lovable
    - Landing Page
    - Dashboard
    - Form Components
  📁 ChatGPT
    - System Prompts
    - Chain-of-Thought
    - Task Templates
  📁 Claude
    - Analysis Prompts
    - Writing Assistance
    - Code Explanation
```

### Tagging Strategy

Use tags for cross-tool discovery:

* `#prompt-engineering`
* `#code-generation`
* `#frontend` / `#backend`
* `#debugging`
* `#documentation`

## Best Practices

<Tip>
  **Test and Refine**: When a prompt works well, save it immediately to Quick
  Access. Refine it over time as you learn what works.
</Tip>

<Tip>
  **Version Your Prompts**: Use Snippets AI's version control to track prompt
  iterations. See what changes improved results.
</Tip>

<Tip>
  **Share with Team**: Export your best prompts to your team workspace so
  everyone benefits from proven templates.
</Tip>

<Tip>
  **Tool-Specific Snippets**: Tag snippets by tool (e.g., #cursor, #lovable) so
  you can filter quickly when searching.
</Tip>

## Advanced Workflow

### Prompt Chains

Build multi-step AI workflows:

1. **Step 1**: Context setup snippet
2. **Step 2**: Task definition snippet
3. **Step 3**: Output format snippet
4. **Step 4**: Refinement instructions snippet

Insert each via Quick Access in sequence for complex tasks.

### Dynamic Placeholders

Save snippets with placeholders:

```markdown theme={null}
Create a {COMPONENT_TYPE} component for {PROJECT_NAME} that handles {FUNCTIONALITY}.
Requirements:

- {REQUIREMENT_1}
- {REQUIREMENT_2}
```

Insert via Quick Access, then fill in placeholders manually.

## What's Next

<Card title="Quick Access Overview" icon="bolt" href="/guides/quick-access-intro">
  Learn the basics of Quick Access if you haven't already
</Card>

<Card title="Snippet Expansion" icon="keyboard" href="/guides/snippet-expansion">
  Learn about text expansion shortcuts as an alternative to Quick Access
</Card>

<Card title="Public Workspaces" icon="users" href="/guides/public-workspaces">
  Explore public prompt libraries from OpenAI, Anthropic, and more
</Card>