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

# Cursor Rules - Vibe Testing in Cursor IDE

> Vibe testing integration for Cursor IDE - test your Lovable, Replit, V0, or Base44 apps without leaving your editor.

<Info>
  **GitHub Repository**: [scoutqa-dot-ai/cursor-rules](https://github.com/scoutqa-dot-ai/cursor-rules)

  **Awesome Cursorrules**: [View on awesome-cursorrules](https://github.com/PatrickJS/awesome-cursorrules)
</Info>

The **Scout rules for Cursor** bring vibe testing directly into your favorite AI code editor. Ask Cursor to test your web applications using natural language - no test scripts, no context switching.

## What is Vibe Testing with Cursor?

**Vibe testing** is AI-powered exploratory testing designed for solo founders, vibe coders, and side project builders. With Scout rules installed in Cursor, you can:

* Say "test my Lovable app" and get real bug reports
* Run accessibility audits without leaving your editor
* Validate user flows before shipping

This is **QA that matches the speed of vibe coding** - test as fast as you build.

## Features

<CardGroup cols={2}>
  <Card title="Natural Language Testing" icon="comments">
    Describe tests conversationally. "Test the checkout flow" or "Find bugs on the homepage."
  </Card>

  <Card title="Platform Support" icon="browsers">
    Works with Lovable, Replit, V0, Base44, Bolt.new, Vercel, Netlify, and any web app.
  </Card>

  <Card title="Accessibility Audits" icon="universal-access">
    Automatically identify WCAG compliance issues and accessibility barriers.
  </Card>

  <Card title="Zero Config" icon="bolt">
    Drop the rules file in your project and start testing immediately.
  </Card>
</CardGroup>

## Installation

### Step 1: Install Scout CLI

First, install the Scout CLI globally:

```bash theme={null}
npm install -g @scoutqa/cli
scoutqa auth login
```

### Step 2: Add Scout Rules to Cursor

<Tabs>
  <Tab title="Quick Setup (Recommended)">
    Create the rules directory and download the Scout rules:

    ```bash theme={null}
    mkdir -p .cursor/rules
    curl -o .cursor/rules/scout.mdc https://raw.githubusercontent.com/scoutqa-dot-ai/cursor-rules/main/scout.mdc
    ```
  </Tab>

  <Tab title="Manual Setup">
    1. Create a `.cursor/rules` directory in your project root
    2. Create a file called `scout.mdc` inside it
    3. Copy the rules from [our GitHub repository](https://github.com/scoutqa-dot-ai/cursor-rules)
  </Tab>

  <Tab title="Global Rules">
    To enable Scout across all your projects:

    1. Open Cursor Settings (`Cmd+,` or `Ctrl+,`)
    2. Search for "Rules"
    3. Add the Scout rules to your User Rules
  </Tab>
</Tabs>

### Step 3: Restart Cursor

After adding the rules, restart Cursor to load them.

## Usage

Once installed, simply ask Cursor to test your application:

<Tabs>
  <Tab title="General Testing">
    ```
    Test my app at https://myapp.lovable.app
    Find any bugs or issues
    ```
  </Tab>

  <Tab title="Login Flow">
    ```
    Test the login flow on https://staging.myapp.com
    Try valid and invalid credentials
    ```
  </Tab>

  <Tab title="Accessibility">
    ```
    Run an accessibility audit on my Replit app
    https://myapp.replit.app
    ```
  </Tab>

  <Tab title="Pre-Deploy">
    ```
    I'm about to deploy - can you run a quick smoke test?
    https://staging.myapp.com
    ```
  </Tab>
</Tabs>

## Example Workflow

<Steps>
  <Step title="Build your feature">
    Write your code as usual in Cursor with AI assistance
  </Step>

  <Step title="Deploy to staging">
    Push to Lovable, Replit, Vercel, or your hosting platform
  </Step>

  <Step title="Ask Cursor to test">
    "Test the new checkout flow on [https://myapp.lovable.app](https://myapp.lovable.app)"
  </Step>

  <Step title="Review and fix">
    Cursor runs Scout and reports issues - fix them in the same session
  </Step>
</Steps>

```
You: I just deployed my Lovable app. Can you test the signup flow?
     https://myproject.lovable.app

Cursor: I'll run Scout to test the signup flow on your Lovable app.

[Running: scoutqa --url https://myproject.lovable.app --prompt "Test signup flow"]

Here's what Scout found:

Issues Detected:
1. Email validation accepts invalid formats (high severity)
2. Password field doesn't show requirements (medium)
3. Submit button missing aria-label (accessibility)

Passed:
✓ Form submits successfully with valid data
✓ Error messages display correctly
✓ Redirect to dashboard works

Recommendations:
- Add regex validation for email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
- Display password requirements above the field
- Add aria-label="Create account" to the submit button

Want me to help fix these issues?
```

## Platform-Specific Examples

### Testing Lovable Apps

```
Test my Lovable app for bugs
https://myproject.lovable.app

Focus on:
- User authentication
- Form submissions
- Mobile responsiveness
```

### Testing Replit Deployments

```
Run a smoke test on my Replit project
https://myapp.replit.app

Make sure the main features work before I share it
```

### Testing V0 Components

```
I built this UI with V0, can you test it?
https://myapp.vercel.app

Check if all the interactive elements work correctly
```

## Troubleshooting

| Issue                  | Solution                                                  |
| ---------------------- | --------------------------------------------------------- |
| Rules not loading      | Restart Cursor after adding the `.cursor/rules` directory |
| Scout CLI not found    | Run `npm install -g @scoutqa/cli`                         |
| Authentication errors  | Run `scoutqa auth login` in your terminal                 |
| Tests failing to start | Ensure your URL is publicly accessible                    |

Check Scout CLI status:

```bash theme={null}
scoutqa auth status
scoutqa --version
```

## Why Use Scout with Cursor?

| Without Scout                  | With Scout                  |
| ------------------------------ | --------------------------- |
| Deploy and hope for the best   | Test before every deploy    |
| Find bugs from user complaints | Catch bugs before users do  |
| Manual accessibility testing   | Automated WCAG audits       |
| Context switch to run tests    | Test without leaving Cursor |

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="What are Cursor rules?">
    Cursor rules are instructions that customize how Cursor's AI behaves in your project. The Scout rules teach Cursor how to run vibe tests on your web applications using the Scout CLI.
  </Accordion>

  <Accordion title="How does this work with Lovable/Replit apps?">
    Scout works with any publicly accessible URL. Deploy your Lovable or Replit app, then ask Cursor to test it. Scout will explore your app and report any issues it finds.
  </Accordion>

  <Accordion title="Can I test localhost?">
    Scout requires publicly accessible URLs. For localhost testing, use a tunneling service like [ngrok](https://ngrok.com/our-product/secure-tunnels):

    ```bash theme={null}
    ngrok http 3000
    # Then test the ngrok URL
    ```
  </Accordion>

  <Accordion title="What's the difference between this and the Claude Code skill?">
    The Cursor rules integrate Scout into Cursor IDE, while the Claude Code skill integrates Scout into Claude Code CLI. Choose based on your preferred editor.
  </Accordion>

  <Accordion title="Is this free?">
    Yes! Scout offers a free tier for solo founders and side projects. Install the CLI and start testing immediately.
  </Accordion>
</AccordionGroup>

## Submit Your Own Rules

Using Scout with a specific framework or platform? Create custom rules and submit them to:

* [awesome-cursorrules](https://github.com/PatrickJS/awesome-cursorrules) - Community collection of Cursor rules
* [cursor.directory](https://cursor.directory) - Cursor rules directory

## Related

* [Scout CLI](/tooling/cli) - Run Scout from any terminal
* [Claude Code Skill](/tooling/claude-code-skill) - Use Scout in Claude Code
* [Kiro Power](/tooling/kiro-power) - Use Scout in Kiro IDE

***

<AccordionGroup>
  <Accordion title="Testing localhost applications">
    Scout requires a **publicly accessible URL** to run tests. Deployed environments like staging and production work immediately.

    For localhost testing, use a tunneling service like [ngrok](https://ngrok.com/our-product/secure-tunnels):

    ```bash theme={null}
    # Start your app, then create a tunnel
    ngrok http 3000
    ```

    Then ask Cursor to test the ngrok URL:

    ```
    Test my app on https://abc123.ngrok.io
    ```

    \*Third-party tunneling services are not affiliated with Scout. Use at your own risk.
  </Accordion>
</AccordionGroup>