Skip to content
Back to search

fugazi-test-automation

MarketplaceWorks with Claude CodeGitHub

A practical library of agents, instructions, and skills designed specifically for QA Automation Engineers, focusing on production-oriented solutions.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/fugazi/test-automation-skills-agents with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/fugazi/test-automation-skills-agents'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/fugazi--test-automation-skills-agents/badge.svg)](/listings/fugazi--test-automation-skills-agents)

HTML

<a href="/listings/fugazi--test-automation-skills-agents"><img src="/api/listings/fugazi--test-automation-skills-agents/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

This repo is a **catalog**. Choose the integration style for your tool.

Integration choices

- **GitHub Copilot (customizations)**: use `.github/agents`, `.github/instructions`, and `.github/skills`. - **Claude/Cursor/OpenCode/Windsurf/etc.**: copy the same content into the tool's repo/workspace rules system, keeping the same structure and naming so your team shares a consistent vocabulary.

Setup guides

| Tool | Setup Guide | | -------------- | -------------------------------------------------------- | | Claude Code | [docs/claude-code-setup.md](./docs/claude-code-setup.md) | | Cursor | [docs/cursor-setup.md](./docs/cursor-setup.md) | | GitHub Copilot | [docs/copilot-setup.md](./docs/copilot-setup.md) | | Antigravity CLI | [docs/antigravity-setup.md](./docs/antigravity-setup.md) | | Windsurf | [docs/windsurf-setup.md](./docs/windsurf-setup.md) |

Option A - Copy into your target repository (most reliable)

1. Copy agents: - From: `agents/` - To: `.github/agents/`

2. Copy instructions: - From: `instructions/` - To: `.github/instructions/`

3. Copy skills: - From: `skills/<skill-name>/` - To: `.github/skills/<skill-name>/`

4. Commit the files to your target repo.

Verify Copilot can see the assets

In your target repository:

1. Confirm files exist at the expected paths: - `.github/agents/*.agent.md` - `.github/instructions/*.instructions.md` - `.github/skills/<skill-name>/SKILL.md`

2. In VS Code, reload the window (or restart VS Code) to refresh Copilot customizations.

3. Open Copilot Chat: - Ensure your `agents` appear in the agent selector dropdown. - If a `skill` does not seem to trigger automatically, explicitly mention it by name in your prompt.

Verify other AI tools can use the content

If you are using Claude/Cursor/OpenCode/Windsurf (or another assistant), verification is typically:

1. Ensure the files are present in the tool's configured rules/prompts scope (repo-level or workspace-level). 2. Start a new chat session so the tool reloads instructions. 3. Ask for a response that should clearly follow a rule (e.g., "avoid `Thread.sleep()`; use explicit waits").

Option B - Git submodule (centralized updates)

Add this repo as a submodule, then **copy/sync** assets into `.github/*` as part of your internal workflow.

Option C - Install via Claude Code Plugin Marketplace

Subscribe to this repository as a plugin marketplace directly from Claude Code:

/plugin marketplace add fugazi/test-automation-skills-agents

Then install the plugin:

/plugin install test-automation-skills-agents@fugazi-test-automation

This will make all 7 specialized QA agents and 10 reusable skills available in your Claude Code session.

**Local / development:**

git clone https://github.com/fugazi/test-automation-skills-agents.git
claude --plugin-dir /path/to/test-automation-skills-agents

Option D - Install skills via skills.sh

You can install skills directly from this repository using **skills.sh**:

- Browse the skills list for this repo: `https://skills.sh/?q=fugazi/test-automation-skills-agents`

Copy/paste any of these commands:

npx skills add https://github.com/fugazi/test-automation-skills-agents --skill playwright-e2e-testing
npx skills add https://github.com/fugazi/test-automation-skills-agents --skill a11y-playwright-testing
npx skills add https://github.com/fugazi/test-automation-skills-agents --skill webapp-selenium-testing
npx skills add https://github.com/fugazi/test-automation-skills-agents --skill qa-manual-istqb
npx skills add https://github.com/fugazi/test-automation-skills-agents --skill accessibility-selenium-testing
npx skills add https://github.com/fugazi/test-automation-skills-agents --skill playwright-regression-testing

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 33 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "fugazi-test-automation",
  3. "owner": {
  4. "name": "Douglas Urrea Ocampo"
  5. },
  6. "metadata": {
  7. "description": "QA Automation AI skills and agents for Claude Code — Playwright, Selenium, API, accessibility, QA Planner, and ISTQB-aligned workflows."
  8. },
  9. "plugins": [
  10. {
  11. "name": "test-automation-skills-agents",
  12. "source": {
  13. "source": "github",
  14. "repo": "fugazi/test-automation-skills-agents"
  15. },
  16. "description": "QA Automation AI skills and agents for Claude Code — Playwright, Selenium, API, accessibility, QA Planner, and ISTQB-aligned workflows.",
  17. "category": "testing",
  18. "keywords": [
  19. "qa-automation",
  20. "playwright",
  21. "selenium",
  22. "sdet",
  23. "testing",
  24. "accessibility",
  25. "a11y",
  26. "api-testing",
  27. "istqb",
  28. "agents",
  29. "skills"
  30. ]
  31. }
  32. ]
  33. }
README.md · README · 516 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img src="copilot-banner.jpg" width="500" alt="Test Automation AI Agents & Skills - Tool-Agnostic QA Automation">
  3. </div>
  4. # Test Automation AI Agents & Skills (Tool-Agnostic) 🚀
  5. A practical library of **agents**, **instructions**, and **skills** designed specifically for QA Automation Engineers, focusing on production-oriented solutions.
  6. This repository is **tool-agnostic by design**: the concepts and content can be used with GitHub Copilot, Claude, Cursor, OpenCode, Devin Desktop, and similar AI assistants.
  7. ---
  8. ## Key Features
  9. This repository is designed to be **copied/embedded into real testing projects** so your AI assistant can actively assist with:
  10. - UI, API, E2E, smoke, and regression testing
  11. - Accessibility testing (WCAG 2.2 AA)
  12. - Flaky test investigation and stabilization
  13. - Test planning (ISTQB-aligned) and documentation
  14. - Framework patterns (Playwright TypeScript, Selenium Java)
  15. > Important: This repository is a **documentation/knowledge base** — no build or test system. The only validation is a dependency-free structural linter: `node scripts/lint-skills.mjs` (**0 errors required**; runs in CI on PRs touching `skills/`, `agents/`, or `instructions/`).
  16. ## What you get
  17. - **Agents** (in `agents/`): persona + responsibilities + boundaries for specialized AI behavior
  18. - **Instructions** (in `instructions/`): lean, scoped essentials (locator priority, no-hard-waits rules) — deep content lives in skills
  19. - **Skills** (in `skills/`): reusable workflows + references + scripts/templates (progressively loaded by supporting tools; otherwise used as playbooks)
  20. ## Repository structure
  21. ```
  22. agents/ # Custom agent definitions (*.agent.md)
  23. instructions/ # Lean, scoped coding essentials (*.instructions.md)
  24. skills/ # Reusable capabilities (skills/*/SKILL.md + resources)
  25. docs/ # Setup guides, standards, and documentation
  26. ├── references/ # Authoring guides and examples
  27. ├── enhancements/ # Enhancement plans (CE audit, deferred decisions)
  28. └── archive/ # Completed/stale planning logs (kept for history)
  29. references/ # Shared reference material (anti-patterns, patterns)
  30. scripts/ # Structural linter (lint-skills.mjs — the repo's only validation)
  31. .claude-plugin/ # Claude Code plugin/marketplace metadata
  32. AGENTS.md # House style, file standards, frontmatter rules
  33. CLAUDE.md # Claude Code entry point + architecture notes
  34. CHANGELOG.md # Release history (Keep a Changelog)
  35. ```
  36. ## Quick start (recommended workflow)
  37. This repo is a **catalog**. Choose the integration style for your tool.
  38. ### Integration choices
  39. - **GitHub Copilot (customizations)**: use `.github/agents`, `.github/instructions`, and `.github/skills`.
  40. - **Claude/Cursor/OpenCode/Devin Desktop/etc.**: copy the same content into the tool's repo/workspace rules system, keeping the same structure and naming so your team shares a consistent vocabulary.
  41. ### Setup guides
  42. | Tool | Setup Guide |
  43. | -------------- | -------------------------------------------------------- |
  44. | Claude Code | [docs/claude-code-setup.md](./docs/claude-code-setup.md) |
  45. | Cursor | [docs/cursor-setup.md](./docs/cursor-setup.md) |
  46. | GitHub Copilot | [docs/copilot-setup.md](./docs/copilot-setup.md) |
  47. | Antigravity CLI | [docs/antigravity-setup.md](./docs/antigravity-setup.md) |
  48. | Devin Desktop (formerly Windsurf) | [docs/devin-desktop-setup.md](./docs/devin-desktop-setup.md) |
  49. ### Option A - Copy into your target repository (most reliable)
  50. 1. Copy agents:
  51. - From: `agents/`
  52. - To: `.github/agents/`
  53. 2. Copy instructions:
  54. - From: `instructions/`
  55. - To: `.github/instructions/`
  56. 3. Copy skills:
  57. - From: `skills/<skill-name>/`
  58. - To: `.github/skills/<skill-name>/`
  59. 4. Commit the files to your target repo.
  60. ### Verify Copilot can see the assets
  61. In your target repository:
  62. 1. Confirm files exist at the expected paths:
  63. - `.github/agents/*.agent.md`
  64. - `.github/instructions/*.instructions.md`
  65. - `.github/skills/<skill-name>/SKILL.md`
  66. 2. In VS Code, reload the window (or restart VS Code) to refresh Copilot customizations.
  67. 3. Open Copilot Chat:
  68. - Ensure your `agents` appear in the agent selector dropdown.
  69. - If a `skill` does not seem to trigger automatically, explicitly mention it by name in your prompt.
  70. ### Verify other AI tools can use the content
  71. If you are using Claude/Cursor/OpenCode/Devin Desktop (or another assistant), verification is typically:
  72. 1. Ensure the files are present in the tool's configured rules/prompts scope (repo-level or workspace-level).
  73. 2. Start a new chat session so the tool reloads instructions.
  74. 3. Ask for a response that should clearly follow a rule (e.g., "avoid `Thread.sleep()`; use explicit waits").
  75. ### Option B - Git submodule (centralized updates)
  76. Add this repo as a submodule, then **copy/sync** assets into `.github/*` as part of your internal workflow.
  77. ### Option C - Install via Claude Code Plugin Marketplace
  78. Subscribe to this repository as a plugin marketplace directly from Claude Code:
  79. ```bash
  80. /plugin marketplace add fugazi/test-automation-skills-agents
  81. ```
  82. Then install the plugin:
  83. ```bash
  84. /plugin install test-automation-skills-agents@fugazi-test-automation
  85. ```
  86. This will make all 7 specialized QA agents and 10 reusable skills available in your Claude Code session.
  87. **Local / development:**
  88. ```bash
  89. git clone https://github.com/fugazi/test-automation-skills-agents.git
  90. claude --plugin-dir /path/to/test-automation-skills-agents
  91. ```
  92. ### Option D - Install skills via skills.sh
  93. You can install skills directly from this repository using **skills.sh**:
  94. - Browse the skills list for this repo: `https://skills.sh/?q=fugazi/test-automation-skills-agents`
  95. Copy/paste any of these commands:
  96. ```bash
  97. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill playwright-e2e-testing
  98. ```
  99. ```bash
  100. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill a11y-playwright-testing
  101. ```
  102. ```bash
  103. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill webapp-selenium-testing
  104. ```
  105. ```bash
  106. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill qa-manual-istqb
  107. ```
  108. ```bash
  109. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill accessibility-selenium-testing
  110. ```
  111. ```bash
  112. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill playwright-regression-testing
  113. ```
  114. ```bash
  115. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill playwright-cli
  116. ```
  117. ```bash
  118. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill api-testing
  119. ```
  120. ```bash
  121. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill grill-me-qa
  122. ```
  123. ```bash
  124. npx skills add https://github.com/fugazi/test-automation-skills-agents --skill qa-investigation
  125. ```
  126. ---
  127. > Note: Copilot's discovery typically looks at canonical locations like `.github/agents` and `.github/skills`. Keeping this repo as a submodule is fine, but you will generally still want a sync step into `.github/*`.
  128. ---
  129. ## Core concepts
  130. ### 1) Agents: "who does the work and how"
  131. Agents define:
  132. - Identity and specialization (e.g., Playwright Test Healer)
  133. - Scope boundaries (what the agent will / will not do)
  134. - Tool access (least-privilege when possible)
  135. - Workflow expectations and output format
  136. Agents live in files named like:
  137. - `lowercase-with-hyphens.agent.md`
  138. Each file includes YAML `frontmatter` within this repo. See `AGENTS.md` for local standards.
  139. Tool-agnostic mapping:
  140. - **Copilot**: custom agent file under `.github/agents/`
  141. - **Other tools**: use the agent body as a dedicated system prompt / mode / persona, and keep the same boundaries
  142. ### 2) Instructions: "the operating system"
  143. Instructions are cross-cutting rules that keep outputs consistent:
  144. - Playwright coding standards, locator strategy, POM patterns
  145. - Selenium Java standards, explicit waits, AssertJ, Allure
  146. - Accessibility expectations (WCAG 2.2 AA)
  147. - CI/CD test pipeline configuration (GitHub Actions, test tiers, parallel execution)
  148. - Single-tag test classification: exactly one tag per test (`@smoke`, `@sanity`, `@regression`, `@e2e`, `@api`, `@destructive`) — never on `describe()`/class level, never combined; `@destructive` runs sequentially, excluded from parallel runs
  149. - Agent authoring guidelines (frontmatter, handoffs, tool selection)
  150. In practice:
  151. - Use instructions when you want **consistent conventions across teams/repos**.
  152. - Treat instructions as **non-negotiable constraints** for day-to-day work.
  153. Tool-agnostic mapping:
  154. - Put the instruction content into your tool's repo-level rules (often a single "rules" file), or keep them split by domain (Playwright, Selenium, a11y) like this repo does.
  155. - If your tool supports file globs/scopes, mirror the intent (e.g., Playwright rules apply to `**/*.spec.ts`).
  156. ## Compatibility notes (VS Code vs GitHub)
  157. Customizations can behave slightly differently depending on where you run Copilot.
  158. - **VS Code**
  159. - Supports agent `model` and `handoffs` (depending on version).
  160. - Great for interactive workflows (planning → generate → debug → heal).
  161. - **GitHub (Copilot Coding Agent)**
  162. - Commonly expects agents under `.github/agents/`.
  163. - Some frontmatter fields may be ignored depending on the environment.
  164. When in doubt, keep the frontmatter minimal and portable:
  165. - Agents: `description` (required), plus optional `name`, `tools`, `target`, `infer`, `handoffs`
  166. - Skills: `name` + `description` (required), optional `license`
  167. - Do **not** pin `model` in agent or skill frontmatter — let the tool harness choose
  168. ### Cross-tool compatibility matrix
  169. The agent **body** and `description` are portable. These frontmatter fields are adapter-specific:
  170. | Field | GitHub Copilot / VS Code | Claude Code | Notes |
  171. | --- | --- | --- | --- |
  172. | `description` | Required | Required | Portable |
  173. | `name` | Display name | Display name | Portable |
  174. | `tools` | Aliases (`read`, `edit`, `search`, …) | Canonical names (`Read`, `Edit`, `Grep`, …) | Use the canonical names above; both harnesses resolve them |
  175. | `model` | Supported | Supported | This repo intentionally does not pin it |
  176. | `handoffs` | Supported (VS Code 1.106+) | Ignored | Claude Code delegates with the `Task` tool |
  177. | `infer` | Supported | Ignored | Claude Code auto-selects by `description` |
  178. | `mcp-servers` | Organization/enterprise | Ignored | Configure MCP at the plugin or user level in Claude Code |
  179. | `target` | Supported | Ignored | Copilot/VS Code only |
  180. | `capabilities`, `scope`, `decision-autonomy` | Ignored (documentation) | Ignored | Keep the body self-contained |
  181. | `.agent.md` extension | Canonical | Loaded by the plugin loader | Keep as-is |
  182. Skills are the most portable surface: `skills/<name>/SKILL.md` is read natively by Claude Code (as a plugin or under `.claude/skills/`) and by Copilot's skill support.
  183. ## Tool-agnostic usage (Claude/Cursor/OpenCode/Devin Desktop)
  184. Use this repo as a shared "QA automation brain" for your team:
  185. 1. Keep this repository as the source of truth.
  186. 2. Sync/copy its content into whichever format your AI tool supports.
  187. 3. Keep the same names so prompts remain consistent across tools:
  188. - "Use the Playwright Test Healer agent."
  189. - "Follow the Playwright TypeScript instructions."
  190. - "Apply the playwright-e2e-testing skill playbook."
  191. Copilot-specific parts are mainly:
  192. - The `.github/*` discovery paths
  193. - Some frontmatter fields that other tools ignore
  194. The testing guidance itself (locator strategies, waits, POM patterns, a11y workflows, ISTQB artifacts) is portable.
  195. ### 3) Skills: "reusable playbooks + resources"
  196. Skills are folder-based capabilities that Copilot can load on-demand.
  197. Key characteristics (by design):
  198. - Progressive loading
  199. - Level 1: Copilot reads only `name` + `description` to decide relevance
  200. - Level 2: Copilot loads the body of `SKILL.md` when relevant
  201. - Level 3: Copilot loads references/scripts/templates only when linked/needed
  202. - Resource bundling
  203. - `references/`: docs loaded into context when referenced
  204. - `scripts/`: executable helpers (deterministic behavior)
  205. - `templates/`: starter code that AI may modify
  206. - `assets/`: static files used as-is
  207. ## How to use agents (day-to-day)
  208. Agents are activated the same way across tools — by referencing the agent in a prompt (its `description` drives selection). The exact UI differs per assistant; the prompts below work everywhere. The flows below are GitHub Copilot-specific examples — for Claude Code, Cursor, Devin Desktop, and OpenCode see the matching [setup guide](#setup-guides).
  209. ### In VS Code (Copilot Chat)
  210. 1. Open Copilot Chat.
  211. 2. Select the agent from the agent dropdown (Custom Agents).
  212. 3. Give a task prompt.
  213. Prompt examples:
  214. - "Use Playwright Test Healer: investigate why `checkout.spec.ts` fails intermittently in CI and propose fixes."
  215. - "As API Tester Specialist: create negative tests for `/v1/orders` covering auth failures and schema validation."
  216. - "As Selenium Test Specialist: generate POM + JUnit 5 tests for login + forgot password."
  217. ### In GitHub (Copilot Coding Agent)
  218. If you're using Copilot on GitHub (agent workflows), keep the agents under `.github/agents/`.
  219. Recommended pattern:
  220. - Use the QA Orchestrator to plan and delegate work
  221. - The orchestrator routes tasks to specialist agents (Playwright planner/generator/healer, API tester, etc.)
  222. ## What agents exist in this repo
  223. This repo currently includes **7 agents** (see `agents/`):
  224. - **QA Orchestrator**: routes test tasks to specialist agents, enforces Test Constitution
  225. - **Playwright Test Planner**: explores an app and produces a structured test plan
  226. - **Playwright Test Generator**: generates Playwright tests from a plan using Playwright MCP
  227. - **Playwright Test Healer**: runs/debugs failing Playwright tests and fixes them iteratively
  228. - **API Tester Specialist**: API test creation (REST Assured / Playwright API / Supertest), auth, contracts, schemas
  229. - **Selenium Test Specialist**: writes maintainable Selenium Java tests (POM, explicit waits, JUnit5, AssertJ)
  230. - **Test Refactor Specialist**: refactors test suites (DRY, POM extraction, parameterization)
  231. ## How to use instructions (when and why)
  232. Use instructions when you want **consistent automation standards** across:
  233. - Multiple QA engineers
  234. - Multiple repositories
  235. - Different test stacks (Playwright vs Selenium)
  236. Examples:
  237. - Add Playwright standards to a new repo: install `instructions/playwright-typescript.instructions.md` into your tool's instructions location (e.g., `.github/instructions/` for GitHub Copilot — see your [setup guide](#setup-guides)).
  238. - Ensure Selenium suites never use `Thread.sleep()`: install `instructions/selenium-webdriver-java.instructions.md` the same way.
  239. - For a11y standards: use the `a11y-playwright-testing` or `accessibility-selenium-testing` skills (loaded on-demand).
  240. ## How to use skills (when they help most)
  241. Skills are best when the team repeats the same "playbook" frequently.
  242. Typical triggers:
  243. - "Write Playwright E2E tests with POM and stable locators" → `playwright-e2e-testing`
  244. - "Run axe-core checks, keyboard navigation, WCAG 2.2 AA" → `a11y-playwright-testing` or `accessibility-selenium-testing`
  245. - "Plan, organize, or optimize regression test suites" → `playwright-regression-testing`
  246. - "Generate ISTQB-aligned artifacts: test plan / bug report / traceability" → `qa-manual-istqb`
  247. - "Inspect a live page, capture evidence, or debug interactively" → `playwright-cli`
  248. - "Find the root cause of a failing or flaky test" → `qa-investigation`
  249. ### Skills catalog (this repo)
  250. | Skill | Best for | Typical prompts |
  251. | -------------------------------- | ------------------------------------------------------------ | ---------------------------------------------------------------------------------------- |
  252. | `playwright-e2e-testing` | Versioned Playwright TypeScript UI specs | "Write Playwright tests for checkout with POM and stable locators." |
  253. | `playwright-cli` | Live browser automation via CLI (snapshot, interact, debug) | "Open a browser, navigate to the login page, and capture a snapshot." |
  254. | `a11y-playwright-testing` | WCAG 2.2 AA checks using Playwright + axe-core | "Add automated a11y scans for auth pages and keyboard nav tests." |
  255. | `webapp-selenium-testing` | Selenium Java automation patterns | "Create Selenium POM + JUnit 5 tests for login and profile update." |
  256. | `accessibility-selenium-testing` | A11y scanning with Selenium + axe-core | "Scan key pages for WCAG issues and generate an Allure-friendly report." |
  257. | `playwright-regression-testing` | Regression strategy + test selection + CI/CD optimization | "Organize tests into tiers (smoke, selective, full) and set up GitHub Actions pipeline." |
  258. | `qa-manual-istqb` | QA artifacts + ISTQB test design techniques | "Create a test plan, cases, and traceability matrix for payments." |
  259. | `api-testing` | REST/GraphQL testing with Playwright and REST Assured | "Create API tests for user endpoints with schema validation." |
  260. | `grill-me-qa` | Guided interview to challenge QA plans & tests strategies | "Grill me on our Playwright migration strategy before we start building." |
  261. | `qa-investigation` | Root-cause investigation of failing/flaky tests | "Find the root cause of the checkout test that fails intermittently." |
  262. ### How skill discovery works
  263. The tool harness uses the `description` in `SKILL.md` frontmatter to decide whether to load a skill. This is a tool-agnostic mechanism — it works the same way across GitHub Copilot, Claude Code, Cursor, Devin Desktop, and similar assistants.
  264. To improve activation:
  265. - Include WHAT the skill does
  266. - Include WHEN to use it
  267. - Include KEYWORDS users will naturally type
  268. If a skill still does not activate automatically:
  269. - Explicitly reference it in your prompt (e.g., "use the skill playwright-e2e-testing").
  270. - Ensure the skill folder is in the canonical location your harness expects (e.g., `.github/skills/` for GitHub Copilot — see your tool's setup guide).
  271. ## Suggested end-to-end workflows
  272. ### Workflow 1 - From requirements to tests (Playwright)
  273. 1. Use `qa-manual-istqb` skill to draft test conditions and test cases.
  274. 2. Use Playwright Test Planner agent to create an E2E plan.
  275. 3. Use Playwright Test Generator agent to generate tests from the plan.
  276. 4. Use Playwright E2E Testing skill as the best-practices reference during implementation.
  277. ### Workflow 2 - Stabilize a flaky suite
  278. 1. Use the Playwright Test Healer agent to identify flaky-test patterns and root causes.
  279. 2. Apply changes (wait strategy, locators, isolation, data seeding).
  280. 3. Use Playwright Test Healer agent to validate and repair remaining failures.
  281. ### Workflow 3 - Accessibility regression prevention
  282. 1. Pick the stack:
  283. - Playwright + axe-core: `a11y-playwright-testing`
  284. - Selenium + axe-core: `accessibility-selenium-testing`
  285. 2. Add a11y checks to critical flows (auth, checkout, forms, modals).
  286. 3. Fail CI on WCAG 2.2 AA violations (with triage exceptions documented).
  287. ### Workflow 4 - Regression testing strategy
  288. 1. Use `playwright-regression-testing` skill to design your regression approach.
  289. 2. Organize tests into tiers:
  290. - Tier 0: Smoke (< 2 min) - critical path, every commit
  291. - Tier 1: Sanity (< 10 min) - core features, every PR
  292. - Tier 2: Selective (< 30 min) - change-based, on merge
  293. - Tier 3: Full (< 60 min) - complete regression, nightly/pre-release
  294. 3. Implement test selection strategies (change-based, risk-based, time-budget).
  295. 4. Set up CI/CD pipeline with GitHub Actions (smoke → selective → full).
  296. 5. Add flaky test management (retry policies, quarantine, suite health metrics).
  297. ### Workflow 5 - API contract validation
  298. 1. Use API Tester Specialist agent.
  299. 2. Cover:
  300. - Auth (401/403)
  301. - Validation errors (400)
  302. - Schema/contract checks
  303. - Idempotency where relevant
  304. - Pagination/sorting/filtering edge cases
  305. 3. Use `api-testing` skill for schema validation patterns (Zod, JSON Schema) and contract testing.
  306. ### Workflow 6 - CI/CD pipeline setup
  307. 1. Use `cicd-testing` instruction for pipeline configuration guidance.
  308. 2. Set up tiered GitHub Actions workflows:
  309. - Smoke (every commit, < 2 min)
  310. - Sanity (every PR, < 10 min)
  311. - Selective regression (on merge, < 30 min)
  312. - Full regression (nightly, < 60 min)
  313. 3. Configure parallel execution with sharding.
  314. 4. Add deployment gates, flaky test handling, and failure notifications.
  315. ## Contributing
  316. ### Add a new agent
  317. 1. Create `agents/<new-agent>.agent.md`.
  318. 2. Follow the structure in `AGENTS.md`:
  319. - Required: frontmatter `description` (single-quoted)
  320. - Recommended: `name`, `target`, `handoffs`
  321. - Optional: `tools` (omit for tool-agnostic agents), `infer`
  322. - Do **not** pin `model` — let the tool harness decide
  323. 3. Include a **Constitution** section (MUST DO / WON'T DO rules) aligned with the QA Orchestrator's Test Constitution
  324. 4. Keep the scope explicit (includes/excludes) and avoid tool overreach
  325. 5. See the [Agent Authoring Guide](./docs/references/authoring-agents.md) for detailed standards
  326. 6. Verify: `node scripts/lint-skills.mjs` — **0 errors required** (CI enforces it)
  327. ### Add a new skill
  328. 1. Create `skills/<skill-name>/SKILL.md` with frontmatter:
  329. - `name`: lowercase-with-hyphens, ≤64 chars
  330. - `description`: WHAT + WHEN + KEYWORDS (critical)
  331. 2. Add supporting resources:
  332. - `references/` for long docs
  333. - `scripts/` for deterministic automation
  334. - `templates/` for scaffolds Copilot can modify
  335. - `assets/` for static content used as-is
  336. 3. Verify: `node scripts/lint-skills.mjs` — **0 errors required** (CI enforces it)
  337. ## Security & safety
  338. - Do not store secrets in agents/skills/instructions.
  339. - Prefer environment variables and secret managers.
  340. - Avoid destructive scripts; require explicit confirmation flags for irreversible actions.
  341. ## Troubleshooting
  342. | Symptom | Likely cause | Fix |
  343. | ---------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------- |
  344. | Agent not visible in selector | Wrong folder path | Ensure `.github/agents/*.agent.md` in target repo |
  345. | Skill never triggers | Description too vague or folder not in canonical location | Improve `description` and ensure `.github/skills/<skill>/SKILL.md` |
  346. | Removed skill name in a prompt | Catalog was consolidated in v3 | See [skill migration plan](docs/archive/enhancements/implementation-plan-skills.md) (archived) |
  347. | Generated tests are unstable | Locator/wait anti-patterns | Follow the locator priority + web-first assertions from Playwright skills |
  348. | Selenium tests flaky | `Thread.sleep()` or missing explicit waits | Use `WebDriverWait` patterns from Selenium instructions/skills |
  349. ---
  350. ## 🏠 Author
  351. - Name: `Douglas Urrea Ocampo`
  352. - Job: `SDET - Software Developer Engineer in Test`
  353. - Country: `Colombia`
  354. - City: `Medellin`
  355. - E-mail: `info@douglasfugazi.co`
  356. - LinkedIn: [https://www.linkedin.com/in/douglasfugazi](https://www.linkedin.com/in/douglasfugazi)
  357. - Contact: [https://douglasfugazi.co](https://douglasfugazi.co)
  358. ---
  359. ## 📄 License
  360. This project is licensed under the **MIT License** - see the [LICENSE](LICENSE) file for details.
  361. ---
  362. <p align="center">Built with ❤️ by Douglas Urrea Ocampo for the QA Community.</p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.