Cursor Skills for QA are useful when your team keeps asking the same AI assistant to review the same kinds of test automation risks. Instead of pasting a long prompt every time, you can package your review expectations into a small, version-controlled skill that Cursor Agent can discover and reuse.

This tutorial shows a practical workflow for QA engineers, SDETs, and automation testers: create a Cursor Agent Skill that reviews UI test changes for weak selectors, brittle waits, shallow assertions, missing negative paths, and regression risk. The goal is not to let AI approve tests automatically. The goal is to make the first review pass more consistent, screenshot-friendly, and easier for a human tester to validate.

Why Cursor Skills for QA Help Repeated Reviews

Cursor’s official Agent Skills documentation describes skills as portable packages with a SKILL.md file and optional scripts, references, and assets. Cursor can discover skills from project-level and user-level directories such as .cursor/skills/ and .agents/skills/. The same docs also note compatibility with Claude and Codex skill directories, which matters if your team wants review guidance to travel across more than one agent workflow.

For QA teams, that packaging is valuable because test review criteria are repetitive. A good reviewer should check locator stability, assertion quality, state setup, cleanup, test data, CI reliability, and whether the test would fail for a real product regression. A skill gives Cursor a reusable checklist instead of relying on each tester to remember the perfect prompt.

Use Case: Review a Playwright Test Diff

Assume a developer opens a pull request with a new Playwright test for checkout. The test passes locally, but you want a QA-focused review before merge. Your team often sees the same issues: CSS-only selectors, assertions that only check page visibility, missing error-path coverage, and tests that depend on pre-existing account state.

The workflow below creates a project-level skill named qa-test-review. Cursor can use it when a tester asks for a review of changed test files. The skill does not replace code review, CI, or exploratory testing. It gives the AI agent clear review rules and a structured output that a QA engineer can verify.

Step 1: Create the Skill Folder

In the repository you want Cursor to review, create this structure:

.cursor/
  skills/
    qa-test-review/
      SKILL.md
      references/
        test-review-rubric.md

Use a project-level folder when the guidance should apply to that repository. Use a user-level skill only when the same guidance is safe across many repositories. For regulated projects or client work, repository-local skills are easier to review in pull requests.

Step 2: Add a QA-Focused SKILL.md

The SKILL.md file is the instruction layer. Keep it direct and practical. Here is a starter version you can adapt:

---
name: qa-test-review
description: Review changed automated tests for QA risks, including selectors, waits, assertions, data setup, and regression coverage.
paths:
  - "**/*.spec.ts"
  - "**/*.test.ts"
  - "tests/**/*.py"
---

# QA Test Review

Use this skill when reviewing automated test changes before merge.

## Review priorities
- Check whether selectors are stable and user-facing where possible.
- Flag fixed waits, timing assumptions, and hidden environment dependencies.
- Identify assertions that only prove the page loaded, not that behavior is correct.
- Look for missing negative, boundary, permission, and data-integrity scenarios.
- Confirm setup and cleanup are explicit enough for CI reruns.
- Separate blocking issues from suggestions.

## Output format
Return:
1. Blocking QA risks
2. Suggested improvements
3. Missing test scenarios
4. Validation steps the human reviewer should run

The paths field keeps the skill focused on test files. Cursor’s docs describe path scoping as a way to surface file-specific guidance only when relevant, which helps keep unrelated tasks cleaner.

Step 3: Add a Review Rubric Reference

Use a reference file when the full checklist is too long for the main skill. This keeps the skill readable while preserving detailed team standards.

# Test Review Rubric

## Selector quality
Prefer role, label, text, test id, or stable app-owned attributes. Flag fragile DOM chains.

## Wait strategy
Prefer web-first assertions and event-driven checks. Flag fixed delays and hidden retries.

## Assertion strength
Each test should verify the business outcome, not only navigation or visibility.

## Data and environment
Review account state, seeded data, cleanup, permissions, and parallel run safety.

## Regression value
Ask: would this fail if the original bug returned?

Cursor’s skills docs say optional directories such as references are useful for extra documentation that can be loaded when needed. For QA teams, this is a clean place for checklists, locator conventions, API assertion standards, or examples of good and bad tests.

Step 4: Ask Cursor for a Structured Review

Open the changed test file or pull request diff in Cursor, then ask for a review that explicitly invokes the workflow.

Try This Prompt

Use the qa-test-review skill to review the changed Playwright tests.
Focus on selector stability, wait behavior, assertion depth, test data setup,
and whether these tests would catch a real checkout regression.
Return blocking risks first, then suggestions, then validation steps.

Good output should be specific. For example, a useful review might say: the test checks that the order confirmation page is visible, but it never verifies the order ID, payment state, item total, or fulfillment status. That is actionable. A vague response like “add more assertions” is not enough.

Step 5: Validate the AI Review Like a QA Engineer

After Cursor returns findings, review them manually. Reject anything that does not match the product behavior, test framework, or repository conventions. For accepted findings, update the test and rerun the smallest relevant command first.

npx playwright test tests/checkout.spec.ts --project=chromium

Then run the broader suite or CI job that normally guards the changed area. The skill should produce review guidance, not final authority.

Common Mistakes to Avoid

Making the skill too broad. A skill that tries to cover every QA topic will become noisy. Start with one review workflow.

Skipping examples. If your team has preferred locator patterns or assertion styles, include short examples in a reference file.

Accepting every suggestion. Cursor can surface useful issues, but it can also overgeneralize. Validate each recommendation against product behavior and existing test architecture.

Screenshot Checklist

  • Repository tree showing .cursor/skills/qa-test-review/SKILL.md.
  • The SKILL.md file open with review priorities visible.
  • Cursor Agent prompt asking for a QA test review.
  • Cursor review output grouped by blocking risks, suggestions, missing scenarios, and validation steps.
  • Terminal or test runner output showing the reviewed test being rerun.

Best Practices for QA Teams

Version the skill with the repository so changes to review standards are visible in code review. Keep the first version small, then add examples when recurring review comments appear. Use path scoping for test file types. Consider disabling automatic invocation if the skill should only run when a reviewer explicitly asks for it.

References

FAQ

Can Cursor Skills approve test automation changes automatically?

No. Treat the skill as a review assistant. A QA engineer or SDET should still verify the findings, inspect the diff, and run the relevant tests before merge.

Should every QA checklist become a Cursor Skill?

No. Use skills for repeated workflows where consistent instructions matter. One-off investigation notes are usually better as normal prompts or project documentation.

Where should a QA team store Cursor Skills?

For repository-specific review rules, store them under a project directory such as .cursor/skills/. For personal reusable guidance, a user-level skills directory may be more appropriate.

Can the same skill include scripts?

Yes. Cursor’s docs describe optional scripts directories. QA teams can use scripts for lightweight checks, but any script should be reviewed before agents run it.

Conclusion

Cursor Skills for QA give test teams a practical way to turn repeated review expectations into reusable agent guidance. Start with one narrow workflow, such as reviewing Playwright or API test diffs. Add a clear SKILL.md, include a small rubric, ask for structured findings, and always validate the result with human review and real test runs.