awesome-copilot-for-testers

🤖 Awesome GitHub Copilot for Testers

This repository is a collection of resources (prompts, instructions, custom agents, agent skills, hooks, plugins, and orchestration examples) for using GitHub Copilot to enhance test automation and quality engineering workflows.

It is designed to help testers, developers, and quality engineers leverage AI to improve their testing practices, automate repetitive tasks, and enhance the overall quality of software products.

[!TIP] 💡 Choose your language:

• 🇬🇧 English
• 🇵🇱 Polski

[!TIP] This project is heavily inspired by Awesome GitHub Copilot - a curated list of resources for using GitHub Copilot effectively. We have adapted the structure and content to focus specifically on testing and quality engineering, providing tailored resources for this domain.

Table of Contents

• 🎯 GitHub Copilot Customization Features
  • 📋 Resources
    • Custom Instructions
    • Custom Prompt Templates
    • Custom Chat Modes (Deprecated)
    • Custom Agents
    • Agent Orchestration
    • Custom Sets
    • Agent Skills
    • Hooks
    • Plugins
  • 📚 Additional Resources
  • 🌱 Contributing
  • 📞 Contact & Support
• 📚 Learning Resources
  • 🇵🇱 Polish Resources
  • 🇬🇧 English Resources

[!IMPORTANT] Check out our free YouTube video to learn more about GitHub Copilot Chat Modes:

🎯 GitHub Copilot Customization Features

GitHub Copilot provides three main ways to customize AI responses and tailor assistance to your specific workflows, team guidelines, and project requirements:

• Custom Instructions: Define how Copilot should behave, what to prioritize, and how to communicate.
• Chat Modes: Create specialized chat modes for different roles or tasks, each with its own set of tools and instructions. With version 1.106 of VS Code, Chat Modes were renamed to Custom Agents.
• Custom Agents: Advanced chat modes that can utilize multiple instructions and tools to perform complex tasks.
• Prompt Templates: Predefined templates for common tasks or questions, allowing for quick and consistent responses.

[!TIP] More You can learn about these features in the official documentation and:

• VS Code Copilot Customization Documentation - Official Microsoft documentation
• Custom Instructions - Tailor Copilot's behavior
• Custom Chat Modes - Advanced chat configuration
• Custom Instructions - Customize Copilot's behavior
• Prompt Files - Using prompt templates
• Custom Agents - Advanced agent configuration
• Agent Skills - Extend agent capabilities with skills
• Hooks - Customize agent behavior with hooks
• Using agents in Visual Studio Code - Overview of agents and orchestration
• Subagents in Visual Studio Code - Using subagents for specialized tasks

[!TIP] Do you want to learn more about effective use of AI and GitHub Copilot for Testers?

Check our AI_Testers Program - a comprehensive Program for mastering AI in test automation!

📋 Resources

Custom Instructions

[!TIP] Usage:

• copy these instructions to your .github/copilot-instructions.md file or
• create task-specific .github/.instructions.md files in your workspace's .github/instructions folder
• use Chat: Attach Instructions command from the command palette to apply them in the current chat

Title	Description	Install
🤖 Custom Instructions for Testers	One-line intent of the rules
API test rules (Playwright + TypeScript)	API test rules for Playwright + TypeScript: HTTP semantics, contract assertions, typed clients, data isolation, and flakiness prevention.
Commit trailer rules	Grammar and enforcement rules for Intent, Intent-Ref, Assisted-by and Comprehension-Attested-by commit trailers: when each is required, how they are validated, and which enforcement layer they belong in.
Playwright E2E rules	Playwright E2E test rules: test intent, isolation, locator strategy, waiting discipline, flake prevention, and diagnostics.
LLM eval rules	Rules for LLM eval suites and prompt files: golden-case discipline, pinned determinism, cheapest-scoring-first, judge rubrics, regression gating against a baseline, and cost control.
Page Objects / App Actions rules (Playwright + TS)	Page Object Model conventions for Playwright + TypeScript: structure, locators, actions, waits, and composition rules.
Playwright Typescript	Playwright test generation instructions with best practices and patterns.
Quality gate workflow rules	Rules for CI quality gates: gate layers, no swallowed failures, soft gates expressed as soft gates, diff-scoped checks, required-check wiring, and sticky PR reporting.
TypeScript style rules	TypeScript style rules: explicit types at API boundaries, typed errors, import hygiene, and async conventions.

Custom Prompt Templates

[!TIP] Usage:

• copy these prompts to your .github/copilot-prompts/ folder
• use /prompt-name in VS Code chat,
• run Chat: Run Prompt command from the command palette

Title	Description	Install
Accessibility audit - deep dive	Run a deeper accessibility audit for a page, sampled set of pages, or user flow with WCAG 2.2 mapping, manual verification guidance, and technical or stakeholder-ready output. For a quick single-URL check, use the a11y-webpage-audit prompt instead.
A11y webpage audit (single URL)	Analyze one webpage for accessibility with WCAG 2.1/2.2 mapping and actionable fixes. Quick single-URL audit; use the a11y-audit-deep-dive prompt for multi-page flows and stakeholder-ready reporting.
Analyze test results	Turn raw test run output - a CI log, JUnit/Playwright report, or console output - into an actionable summary: failure clusters, likely root-cause groups, flakiness suspects, and what to investigate first.
API test plan and test generator	Create a risk-based API test plan and generate example automated tests from API definitions (OpenAPI/Postman/custom docs). API-focused end-to-end flow: plan first, then tests.
Audit collection health	Audits a customization collection as a whole: inventory, frontmatter and structural conformance against the house conventions, description trigger quality, overlap and collision clusters between near neighbours, broken cross-references, orphaned and missing resources, drift between assets, plugin copies and generated docs, and which assets have no behavioural test.
Audit quality debt and silent skips	Audits the three debts - technical, intent and comprehension - and inventories every silent skip in the repo: skipped tests, disabled lint rules, ts-expect-error, continue-on-error, coverage ignores, lowered thresholds, raised retries and expired waivers.
Create a bug report	Turn rough tester notes, screenshots, logs, or observed behavior into a professional bug report with severity, reproducibility, and evidence guidance.
Create a new skill	Create a new skill (SKILL.md) for VS Code Copilot. Analyzes existing skills for patterns, guides through design decisions, creates the skill file with supporting resources, and validates against best practices.
Derive a quality contract	Derives which testing practices are MUST, SHOULD or COULD for this specific project from its risk profile, team maturity and product surfaces, then reports a PRESENT/PARTIAL/MISSING/WAIVED gap matrix and an ordered remediation plan.
Derive test cases from code	Read a function, module, or diff and derive white-box test cases from its actual branches, boundaries, and error paths - then compare against existing tests to expose coverage gaps.
Design an LLM eval suite	Designs and implements an offline eval suite for an LLM feature: golden, edge and negative cases per prompt template, the cheapest scoring strategy that can actually fail, pinned determinism, a regression gate against a committed baseline, and the CI job that runs it.
Analyze and explain code	Analyze and explain the selected code, the active file, or a provided snippet: purpose, structure, patterns, risks, and what a tester should verify
Explain a test failure	Diagnose a failing test from an error message, stack trace, CI log, or trace file: classify the root cause as app defect, test bug, environment issue, or flakiness - without changing any code. Use the fix-tests prompt when you want the failure fixed.
Fix failing tests	Diagnose and fix failing tests by addressing root causes, without weakening assertions or masking defects
Generate exploratory testing charters	Create prioritized, timeboxed exploratory testing session charters from a feature description, release notes, or live app exploration - with risk focus, test ideas, and oracle notes for each session.
Generate Gherkin scenarios	Convert a user story, acceptance criteria, or feature description into well-formed Gherkin scenarios (Given/When/Then) with scenario outlines for data variations, ready for BDD frameworks like Cucumber or Playwright-BDD.
Generate test data	Design realistic and edge-covering test data packs from requirements, constraints, or existing test plans for manual and automated testing.
Generate manual test cases	Turn a feature description, acceptance criteria, exploratory notes, or a test plan into detailed manual test cases with risk tags, expected results, and automation hints.
Map requirements to test coverage	Build a Requirements Traceability Matrix from a PRD, user stories, or acceptance criteria against existing tests: what is covered, at which level, what is missing, and which gaps carry the most risk.
Migrate tests to Playwright	Migrate existing UI tests from Cypress, Selenium, Puppeteer, or Protractor to Playwright while preserving coverage: translate idioms to Playwright best practices, run both suites where possible, and report an honest migration status per test.
Performance and reliability test planner	Design a performance and reliability test strategy and propose concrete load/soak tests for critical user flows.
Explore a website and gather network requests using Playwright MCP	Explore a website with Playwright MCP while capturing network requests and responses. Use the playwright-explore-website prompt instead when network traffic is not needed.
Explore a website and propose test cases	Explore a website with Playwright MCP and propose test cases. Use the playwright-explore-website-requests prompt instead when network traffic should also be captured.
Generate tests based on a scenario using Playwright MCP	Generate a Playwright test from a scenario description by first executing it live via Playwright MCP. Use the test-generator prompt instead when generating from a written test plan file.
QA strategy - edge cases, security and attack scenarios	For any feature, user story, or API spec: instantly generate a structured scenario matrix covering edge cases, boundary values, OWASP Top 10 security attacks, and adversarial sequences.
Record the intent behind a change	Finds the high-risk surface in a change range, checks whether a rationale already exists in commit trailers, ADRs or a module intent register, and drafts an Intent trailer for the author to confirm - why now, what constrained the shape, what was rejected.
Refactor tests to page objects	Refactor UI test specs into a clean Page Object Model without changing what the tests verify: extract locators and actions, keep assertions in tests, and prove behavior is unchanged by rerunning the suite.
Analyze regression scope	Turn a diff, PR summary, changed files, or hotfix description into a prioritized regression scope with a minimal confidence suite and retest guidance.
Review requirements for testability	Review a user story, PRD, or acceptance criteria for ambiguity, missing states, and untestable statements - before implementation starts. Produces concrete clarifying questions and rewritten, testable acceptance criteria.
Scope and gate this change	Tags a diff into file and hunk tags, resolves which quality practices the change makes relevant, verifies diff coverage and intent rationale, and returns severity-ranked findings with implementable remediation briefs.
Stabilize flaky tests	Hunt down intermittently failing tests, classify the flakiness root cause (timing, environment, data, state leakage), fix it properly, and prove stability with repeated runs. Use the fix-tests prompt for tests that fail consistently.
Tech debt audit - test automation code review	Ruthlessly audit automated test code for anti-patterns: fragile selectors, hardcoded waits, missing assertions, test interdependencies, credential leaks, and more. Produces a severity-ranked debt report with line-level citations and concrete fixes.
Generate tests based on test plan	Generate automated tests from a written test plan file, matching the project's existing framework. Use the playwright-generate-test prompt instead when starting from a scenario description.
Test LLM guardrails and injection resistance	Maps the trust boundaries of an LLM feature, tests the runtime guardrails around model output - schema, PII, moderation, rendering, tool authorization, resource caps, fail-closed behaviour - and runs an adversarial corpus through every content channel including retrieval and tool results.
Generate a basic test plan	Generate a quick, single-pass test plan for a website from light exploration. Use the test-planner prompt for a comprehensive, interactive plan covering web and API.
Generate a comprehensive test plan	Collects environment details and produces a prioritized test plan with web and API scenarios. Use the test-plan-basic prompt for a quick single-pass plan without deep exploration.
Verify acceptance criteria	Compare implementation evidence against acceptance criteria and show what is met, partial, missing, or still untestable.

Custom Chat Modes (Deprecated)

[!TIP] Usage (in VS Code prior to version 1.106):

• create new chat modes:
  • using the command Chat: Configure Chat Modes... or
  • from set mode menu Agent -> Configure Modes,
• then switch your chat mode in the Chat input from set mode menu Agent -> Configure Modes

[!WARNING] With version 1.106 of VS Code, Chat Modes were renamed to Custom Agents. They contain .agent.md suffix and should be stored in the .github/agents/ The chat mode files below are now deprecation stubs that link to their custom agent replacements.

Title	Description	Install
Accessibility Expert mode (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the accessibility custom agent instead.
Playwright Automation Engineer (TypeScript) mode (detailed) (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the playwright-expert-detailed custom agent instead.
Playwright Automation Engineer (TypeScript) mode (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the playwright-expert custom agent instead.
QA Strategist - Edge Cases, Security & Attacks (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the qa-strategist custom agent instead.
Tech Debt Auditor - Test Automation Code Reviewer (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the tech-debt-auditor custom agent instead.
Test Automation Architect (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the test-automation-expert custom agent instead.
Test Planner (Deprecated)	(Deprecated) Chat modes were replaced by custom agents in VS Code 1.106. Use the test-planner custom agent instead.

Custom Agents

[!TIP] Usage:

• create new agents:
  • using the command Chat: Configure Custom Agents... or
  • from set mode menu Agent -> Configure Custom Agents,
• then switch your agent in the Chat input from set mode menu Agent -> <Custom Agent Name>

Title	Description	Install
Accessibility Expert	A specialized Agent focused on ensuring all code adheres to WCAG 2.1 accessibility standards.
API Test Automation (from OpenAPI spec)	Generate REST API tests from an OpenAPI spec (language/framework provided by the user).
Change Gate Reviewer - scope, verify, brief	Reviews a single diff against the project quality contract: tags the change, scopes only the practices the change makes relevant, verifies diff coverage, checks that high-risk surface carries a recorded rationale, and returns severity-ranked findings with remediation briefs. Use before committing, pushing or opening a PR, and on any change that touches public surface, auth, migrations, prompts or dependencies.
LLM Feature Test Engineer - evals, guardrails, red team	Designs and implements eval suites, runtime guardrail tests and adversarial prompt-injection suites for LLM-powered features, then wires the regression gate into CI. Use when a product ships prompts, agents or RAG and its quality is currently verified by eyeballing output, when a model or prompt upgrade needs a regression check, or when an AI feature is about to reach real users.
Openapi Test Automation Expert	Generates and maintains automated tests driven by an OpenAPI/Swagger schema (contract + behavior) and supports testers with automation best practices. For general API test generation without a spec, use the api-test-automation agent.
Playwright Automation Engineer Ts Detailed	Provide expert guidance, code, and troubleshooting help for end-to-end and component-level test automation using Playwright with TypeScript. Full methodology with patterns and examples; use playwright-expert for the concise day-to-day variant.
Playwright Automation Engineer Ts	Provide expert guidance, code, and troubleshooting help for end-to-end and component-level test automation using Playwright with TypeScript. Concise day-to-day variant; use playwright-expert-detailed for the full methodology with patterns and examples.
Qa Strategist	Kills happy-path thinking. For every feature, spec, or user story the agent immediately surfaces edge cases, boundary values, security attacks (OWASP Top 10), and adversarial scenarios before a single line of test code is written.
Quality Contract Architect - derive, then enforce	Derives and maintains a project quality contract - which testing practices are mandatory for this risk profile, maturity level and product surface - then reports the gap between the contract and reality with an ordered remediation plan. Use when a project needs an evidence-derived testing strategy instead of a wish list, when a team argues about which practices are required, or when a legacy repo needs an honest quality baseline.
Quality Debt Auditor - technical, intent, comprehension	Audits the three debts across a repository: technical (practices the contract requires but the repo lacks), intent (high-risk changes with no recorded rationale) and comprehension (code shipped that nobody has attested to understanding), plus the silent skips that hide all three. Use for a quarterly quality review, before taking over an unfamiliar codebase, or when an AI-heavy repo is outgrowing the team that maintains it.
Rubber Duck 2.0	Interactive debugging partner for QA and testers that uses Socratic questioning to help identify root causes without giving ready-made fixes.
Skill Librarian - audit a customization collection	Audits a collection of customization assets as a whole rather than one at a time: frontmatter and structural conformance, description trigger quality, overlap and trigger collisions between near neighbours, broken cross-references, orphaned and missing resources, drift between skills, plugins and the README, and which assets have no behavioural test at all. Use when a collection has grown past manual review, before publishing or a release, when two skills keep competing for the same request, when a contribution needs checking against house conventions, or when nobody can say what is in the collection any more.
Tech Debt Auditor	Audits the repo for technical debt, quantifies impact/risk, and produces a prioritized remediation plan with small, safe PR-sized recommendations.
Test Automation Expert	Help engineers craft robust, fast, and maintainable automated tests that deliver actionable feedback and integrate seamlessly into modern SDLC pipelines.
Test Code Reviewer - Test Automation Anti-Pattern Hunter	A ruthless, opinionated code reviewer for automated test suites. Hunts down anti-patterns, tech debt, and bad practices in test code - from fragile selectors and hardcoded waits to test interdependencies, weak assertions, and credential leaks. For repository-wide technical debt audits, use the tech-debt-auditor agent instead.
Test Planner	An expert QA test planner agent that explores web applications and APIs to create comprehensive, risk-prioritized test plans.
UI Test Automation	This custom agent creates and maintains Playwright tests for UI automation. Used in courses from AI_Testers (courses about test automation for UI and REST API with AI).

Agent Orchestration

[!TIP] Usage: Just pick an agent set and install the agents you want to orchestrate together, then switch to main agent from the set and start chatting. The agents will automatically trigger each other based on the defined orchestration flow.

Docs:

• https://code.visualstudio.com/docs/copilot/agents/subagents
• https://code.visualstudio.com/updates/v1_109#_control-how-custom-agents-are-invoked

Minimal Agent Orchestration Example

Contains 4 agents.

Title	Description	Install
Analyst	Analyst: pattern analysis, risk assessment, and insight generation
Explorer	Explorer: fast read-only codebase mapping and pattern discovery
Orchestrator	Orchestrator: multi-agent conductor with explicit stop gates
Planner	Planner: research-driven phased plan with test strategy and risks

VS Code Copilot Agents Pack (Architect + Test Architect)

Contains 10 agents.

Title	Description	Install
Architect Subagent	Architect: ADR-ready trade-offs, NFR impacts, threat models, and test implications
Code Review Subagent	Code review: correctness, risks, security, tests, and regressions (no fixes)
Docs Writer Subagent	Docs: README updates, usage examples, API docs, and release notes – copy-paste ready
Explorer Subagent	Explorer: fast read-only map of files, usages, patterns, and entry points
Implementer Subagent	Implementer: TDD-first phase delivery with minimal diffs and quality gates
Orchestrator Agent	Orchestrator: multi-agent lifecycle with explicit stop gates
Planner Agent	Planner: research-driven phased plan with tests and NFRs
QA Strategy Subagent	QA strategy: test pyramid, coverage goals, quality gates, and flakiness mitigation
Researcher Subagent	Researcher: extract conventions, key files, patterns, and examples at scale
Security Auditor Subagent	Security audit: threat model, risk scan, OWASP mapping, and concrete mitigations

UI + API Test Automation Orchestration Pack

Contains 8 agents.

Title	Description	Install
OpenAPI Explorer	Analyze OpenAPI/Swagger spec and produce an API inventory + test matrix.
BE Test Implementer	Implement backend/API tests from the OpenAPI-driven matrix.
FE Explorer (Playwright MCP)	Explore the frontend via Playwright MCP, map flows, suggest robust locator strategy and test targets.
FE Test Implementer	Implement Playwright frontend tests following the provided plan and repo conventions.
QA Orchestrator	Orchestrate subagents to design, implement, review and verify FE/BE tests (OpenAPI + Playwright MCP).
Solution Reviewer	Review FE/BE tests for correctness, maintainability, flakiness, and alignment with the plan.
Test Planner	Combine OpenAPI + FE exploration into a prioritized test plan with architecture and tasks.
Test Runner & Verifier	Run test suites, diagnose failures, and verify the final solution end-to-end.

UI + API Test Automation Orchestration Pack (Minimal)

Contains 5 agents. Used in courses from AI_Testers (courses about test automation for UI and REST API with AI).

Title	Description	Install
Test Coder Agent (Minimal)	A minimal agent that implements tests based on a provided test plan. It focuses on following best practices for test implementation.
Explorer Agent (Minimal)	A minimal agent that explores the application and gathers information for test planning. It focuses on following best practices for exploration and data collection.
Test Planner (Minimal)	Combine exploration into a prioritized test plan with architecture and tasks.
QA Orchestrator (Minimal)	Orchestrate subagents to design, implement, review and verify FE/BE tests (OpenAPI + Playwright MCP).
Test Framework Starter Agent (Minimal)	A minimal agent that sets up a test framework.

🎯 Quick Start: Using Orchestrator with Subagents

Once you've installed the agents, here are some example prompts to get started:

Example 1: Analyze a Feature for Tech Debt (Minimal Example)

@Orchestrator Analyze this codebase for technical debt and maintainability issues.

The Orchestrator will:

1. Clarify your scope and constraints
2. Invoke Explorer and Analyst in parallel to research the codebase
3. Present findings and recommendations for your approval

Example 2: Plan an Implementation (Full Example)

@Orchestrator Plan implementing: Add real-time notifications to our API.
Constraints: Must be backward compatible, no database schema changes.

The Orchestrator will:

1. Invoke Planner to create a phased implementation strategy
2. Planner will invoke Explorer to map the codebase and Architect for trade-offs
3. Present a complete plan with test strategy and risk mitigation

Example 3: Security Assessment

@Orchestrator Assess the security posture of our authentication system.

The Orchestrator will:

1. Invoke Explorer to find all auth-related files
2. Invoke Security-Auditor to analyze patterns and identify vulnerabilities
3. Synthesize findings into actionable recommendations

[!TIP] For more detailed workflows and best practices, see the Minimal Agent Orchestration Example README

Custom Sets

Custom sets are combinations of custom instructions, prompt templates, and chat modes (or custom agents) designed for specific use cases.

[!TIP] Set elements work together to provide a tailored experience for specific testing scenarios. But you can also use them separately as needed.

[!WARNING] Concept of Sets is not natively supported in VS Code Copilot.

Beyond Codegen 2.0 Strategy - Resource Set

Contains 1 prompt, 1 agent

Title	Type	Description	Install
Edge Case Scenario Generator (BDD)	Prompt	Generates a complete, risk-based set of BDD test scenarios, focusing on edge cases, state validation, and boundary conditions.
AI Test Architect: Beyond Codegen 2.0 Strategy	Agent	Designs and oversees the implementation of the strategic, two-stage Beyond Codegen 2.0 test generation architecture.

AI Product QA - Resource Set

A set of resources for AI Product QA - Resource Set

Title	Type	Description	Install
No resources found

Quality Governance - Resource Set

A set of resources for Quality Governance - Resource Set

Title	Type	Description	Install
No resources found

Sdlc Qa

A set of resources for Sdlc Qa

Title	Type	Description	Install
No resources found

Agent Skills

Agent Skills are folders of instructions, scripts, and resources that GitHub Copilot can load when relevant to perform specialized tasks. Agent Skills is an open standard that works across multiple AI agents, including GitHub Copilot in VS Code, GitHub Copilot CLI, and GitHub Copilot coding agent.

[!TIP] Usage:

• copy these skills to your .github/skills/ or .claude/skills/ folder

The correct folder structure is:

.github/
└── skills/
    └── <my-skill>/
        ├── SKILL.md
        └── resources/
            └── example.txt

where <my-skill> is the name of your skill. Name it after the activity it performs, preferably in gerund form, e.g. analyzing-regression-scope or auditing-accessibility (a few older skills predate this convention). The SKILL.md file contains the main instructions and logic for the skill, while the resources/ folder can contain any additional files needed for the skill's operation (e.g. templates, examples, reference materials).

Agents will automatically detect and load these skills if the agent finds them relevant to the current chat context (based on the skill's name and description).

[!WARNING] Agent Skills are currently in preview and may require enabling experimental features in VS Code settings.

Title	Description	Install
analyzing-quality-metrics	Defines, computes, and interprets test and quality metrics: pass rate, flake rate, suite duration, defect escape rate, time to detect, and coverage with its caveats. Use when building a QA dashboard, reporting suite health to stakeholders, comparing releases over time, or when a coverage percentage or a bug count is being treated as a measure of quality. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
analyzing-regression-scope	Analyzes diffs, changed files, hotfixes, and release candidates to identify where regression risk spreads and what must be retested first. Use when scoping retest after a change, reviewing QA impact for a pull request, or building a minimal confidence suite for release validation. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
api-playwright-test-developer	Writes and reviews API automation tests with Playwright Test, covering setup/teardown, assertions, data management, and hybrid API+UI flows. Use when creating backend API tests, contract checks, data-driven API coverage, API+UI hybrid workflows, or reviewing existing Playwright API suites.	manual
assessing-comprehension-debt	Measures the risk that code shipped without anyone understanding it: a teach-back attestation on high-risk changes, a risk band from changed-code complexity, diff size and whether a human explanation accompanied it, and optional AI-authorship provenance. Findings stay advisory by design. Use when an AI-assisted codebase grows faster than the team reads it, when reviews are rubber-stamped, when nobody can explain a module that ships weekly, or when leadership asks how much of the code the team can actually maintain. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
assessing-release-readiness	Produces an evidence-backed go/no-go recommendation: exit criteria status, open-defect risk profile, coverage against risk, environment parity, rollback readiness, and the residual risk stated plainly. Use when preparing a release sign-off, when someone asks whether a build is ready to ship, or when a decision to release is being made on impressions rather than evidence. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
attesting-manual-verification	Records human verification - code review, exploratory sessions, UAT, accessibility passes, UX and observability reviews - as dated, attributed attestations in a register, so human-centric practices stay in the quality contract without pretending to be automated checks. Use when a strategy requires verification no tool can prove, when sign-off evidence is scattered across chats and tickets, when a gap matrix needs to distinguish "attested" from "passed", or when an audit asks who verified what and when. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
auditing-accessibility	Performs webpage and user-flow accessibility audits with WCAG 2.2 guidance, manual verification checklists, prioritized remediation output, and stakeholder-ready summaries. Use when auditing accessibility on a URL, triaging suspected a11y issues, or producing technical findings with practical next steps. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
code-review-advanced	Performs evidence-driven code review for pull requests, legacy modules, and quality-critical changes. Use when reviewing complex or multi-file changes, test automation suites, architectural refactors, or hot paths that need analysis of correctness, maintainability, security, performance, test quality, and operability risks. Provides structured feedback with severity-ranked findings, actionable recommendations, and clear rationale. For a fast sanity check of a small diff or single file, use the code-review skill instead. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
code-review	Performs a quick, lightweight review of a small diff or single file, giving concise feedback on correctness, readability, tests, and obvious risks. Use when the user asks for a fast sanity-check review of a small change. For test-automation suites, architectural refactors, security-sensitive paths, or multi-file reviews, use the code-review-advanced skill instead.	manual
communicating-quality-findings	Shapes QA output for the person who has to act on it: result and blocker in the first two lines, one decision per report, findings ordered by what they cost, the long artifact in a file and the decisions in the message, and magnitude stated in units the reader can count. Use when a report is accurate but nobody acts on it, when a finding set is too long to read under time pressure, when the same findings must be retold for a developer, a release manager, and an on-call engineer, or when the request mentions "too long", "make this readable", "just tell me what to do", "so what", or "summarize this for stakeholders". Pairs with unslop-answers, which makes the same report honest. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-custom-agents	Creates GitHub Copilot custom agents (.agent.md) for VS Code. Use when defining a specialized agent role, selecting a minimal toolset, referencing supporting skills, or shipping install-ready agent examples with clear boundaries and collaboration rules. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-hooks	Creates GitHub Copilot hooks for VS Code using hooks.json, supporting scripts, and companion docs. Use when automating deterministic checks, pre/post tool policies, or reusable hook packs that need safe defaults, observability, and clear installation guidance. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-instructions	Creates GitHub Copilot instruction files for VS Code, including repository guidance and scoped .instructions.md rules. Use when encoding project conventions, choosing applyTo patterns, or shipping install-ready instruction examples with rationale and guardrails. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-orchestration-packs	Creates agent orchestration packs: cooperating .agent.md files with an orchestrator, subagents, matched handoffs, minimal tool grants, and a shared handoff packet contract. Use when one agent role is too broad for a job, when a workflow needs explore, plan, implement, review, and verify as separate roles, or when a pack fails the orchestration lint because a handoff target does not resolve. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-plugins	Packages repository skills as installable Copilot plugins: marketplace registration, plugin.json manifests, generated skill copies, and the sync check CI enforces. Use when bundling one or more skills for installation, when adding a plugin to the marketplace, or when npm run lint reports that a plugin copy has drifted from its source skill. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-prompts	Creates GitHub Copilot prompt files (.prompt.md) for VS Code. Use when building reusable workflow starters that route work to the right agent, collect the right inputs, and ship with install-ready templates, examples, and validation guidance. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
creating-skills	Creates GitHub Copilot skills with reusable workflows, companion resources, and validation gates. Use when packaging repeatable expertise into a SKILL.md folder, deciding what belongs in the skill body versus resources, or producing install-ready skill examples for a team or collection. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
deriving-a-quality-contract	Derives a project-specific quality contract from three axes - risk profile, team maturity, and product surface - labelling each testing practice MUST, SHOULD, or COULD, then produces a PRESENT/PARTIAL/MISSING/WAIVED gap matrix with an ordered remediation plan. Use when a project has no agreed testing strategy, when a team argues about which practices are mandatory, when onboarding a legacy or inherited repository, when a quality strategy document has to be derived from evidence instead of opinion, or when someone asks "what testing should we actually be doing here". 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
designing-functional-tests	Designs risk-based functional test plans, manual test cases, regression slices, and automation handoff packs from requirements, URLs, or exploratory notes. Use when preparing manual QA coverage before automation, turning feature descriptions into scenario catalogs, or converting exploratory findings into structured test assets. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
designing-test-data	Designs realistic, boundary-heavy, and role-aware test data packs for manual and automated testing. Use when a feature needs deliberate inputs and fixtures before execution, when edge-case values keep being improvised, or when automation needs stable example data with setup notes. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
documenting-test-suites	Writes the documentation a test suite needs to be usable by someone who did not build it: run instructions, environment setup, tag glossary, ownership, fixture and data notes, and architecture decision records. Use when onboarding someone into a suite, when "how do I run these" keeps being asked, when a test architecture decision needs recording, or when a suite is inherited with no documentation. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
generating-quality-gate-workflows	Generates the CI workflow that enforces a quality contract: layered jobs from fast local hooks to release gates, per-practice steps for JS/TS toolchains, diff-scoped checks, sticky PR reporting, required-check wiring, and a severity policy deciding what fails the build. Use when quality practices are agreed but not enforced, when CI runs everything on every commit, when a gate reports green while the check it runs cannot fail, or when a per-change gate needs to post findings on the pull request. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
governing-quality-waivers	Turns "we will skip this check for now" into a dated, attributed, expiring waiver with a stated reason and owner, inventories the silent skips already hiding in a repo - skipped tests, disabled lint rules, ts-expect-error, continue-on-error, lowered thresholds, coverage ignores - and reports expired waivers as findings. Use when a team wants to bypass a quality gate, when skip lists and quarantined tests accumulate without owners, when an audit asks why a check is off, or when a repo needs to know what it has quietly stopped enforcing. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
handling-sensitive-test-data	Keeps test data legally and operationally safe: classifies personal data, replaces production copies with synthetic or anonymized fixtures, manages secrets in local runs and CI, strips personal data from traces and HAR files, and sets retention rules. Use when tests run against a production data copy, when fixtures contain real names or emails, when a data protection review is coming, or when test artifacts might carry personal data into CI logs. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
migrating-tests-to-playwright	Migrates Cypress, Selenium, WebdriverIO, or Protractor suites to Playwright in staged slices, each with a parity gate before the old test is deleted. Use when porting a legacy browser suite, when deciding which tests are not worth porting, when a half-finished migration has stalled with two suites running in parallel, or when a suite migration needs a plan before anyone starts translating files. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
mocking-network-and-time	Decides what to fake and stubs it correctly: network interception with Playwright route or HAR replay, MSW handlers, fake clocks, and fixed timezones. Use when a test depends on a third party, when a date-sensitive test breaks overnight, when a suite is slow because it calls real services, or when a mocked test stays green while production is broken. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
planning-exploratory-testing	Runs session-based exploratory testing: writes charters, timeboxes sessions, applies coverage heuristics and tours, captures notes as evidence, debriefs, and converts findings into bug reports and automation candidates. Use when a feature needs testing before requirements settle, when scripted cases keep passing while users hit problems, when a release needs a risk sweep with limited time, or when the request mentions charters or exploratory sessions. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
prd-generator	Produces production-ready Product Requirements Documents (PRDs) for software systems and AI-powered features, with clear problem framing, measurable outcomes, scoped functionality, testable requirements, and explicit risks. Use when the user wants to write a PRD, define requirements, plan a feature, or turn a vague product idea into an implementation-ready specification. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
recording-change-intent	Requires an externalised rationale for high-risk changes - new public exports, new endpoints, auth edits, migrations, removed guards - recorded as an Intent commit trailer, an ADR reference, or a module intent register, and reports high-risk changes that carry none. Use when agent-generated or AI-assisted changes ship without a recorded why, when reviewers cannot tell what a diff was for, when a codebase is losing its decision history, or when setting up an intent gate alongside test and coverage gates. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
reporting-bugs	Transforms rough tester notes, screenshots, console output, or observed behavior into reproducible defect reports with severity, evidence, and follow-up guidance. Use when logging bugs, triaging intermittent issues, or rewriting vague defect notes into developer-ready reports. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
requirements-test-coverage-mapper	Maps requirements (PRD, user stories, acceptance criteria) to planned test coverage via a Requirements Traceability Matrix, exposing coverage gaps, risks, test levels, prioritization, and automation candidates. Use when designing coverage from a specification, checking coverage completeness for a PRD or user story, finding missing acceptance criteria, or building a risk-based regression strategy. When the tests already exist and the matrix has to be extracted from them, verified, and kept accurate, use the tracing-requirements-to-code skill instead. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
reviewing-ai-output-groundedness	Human review protocol for whether AI output is grounded in its sources: claim-by-claim attribution, hallucination classes, citation verification, sampling that is defensible, and a recorded attestation because groundedness cannot be fully automated. Also covers the responsible-AI pass - harmful output, bias, disclosure and privacy. Use when reviewing a RAG or summarisation feature, when factuality matters more than fluency, or when an eval suite needs the human check it cannot replace. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
running-visual-regression-tests	Sets up and maintains visual regression testing: what to snapshot, baseline strategy, masking dynamic regions, threshold tuning, containerized baselines, and the review-and-update workflow. Use when styling regressions escape to production, when snapshots fail on every machine or every run, when baselines are being updated without being looked at, or when deciding whether visual testing is the right tool at all. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
scoping-change-relevance	Classifies a diff into file tags and hunk tags - new public export, new endpoint, modified auth, SQL string, migration, added dependency, touched prompt - then maps each tag to the quality practices it makes relevant, producing a defensible per-change check scope instead of running everything or guessing. Use when deciding what to test for a specific pull request, when a full regression run is too slow to gate on, when a pre-push or PR gate needs a scope someone can argue with, or when asked "which checks does this change actually need". 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
static-code-analysis-typescript	Creates, reviews, and modernizes static code analysis setups for Node.js and TypeScript repositories, covering ESLint flat config, typescript-eslint, tsconfig, Prettier, import sorting, Husky, lint-staged, package.json quality scripts, and CI quality gates. Use when setting up or auditing linting, formatting, type-checking, commit hooks, or GitHub Actions quality checks in a TypeScript project. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
tech-debt-analysis	Analyzes technical debt in codebases, test suites, architecture, dependencies, and delivery workflows using observable signals. Use when auditing repository health, explaining slow delivery or flaky tests, prioritizing refactoring, or building an evidence-based remediation roadmap with risk, effort, and ROI. Use when user asks for technical debt analysis, repository audit, or refactor planning. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
test-driven-development-quick	Runs the red-green-refactor loop with a compact set of rules: one failing test, the minimal code to pass it, cleanup under green. Use for routine test-first work on a single behavior or a small bug fix, and when the request mentions TDD, test-first, red-green-refactor, or writing the test before the code. For multi-unit features, outside-in double loops, legacy code without tests, or a session that needs a written cycle log, use the test-driven-development skill instead.	manual
test-driven-development	Drives implementation test-first through red-green-refactor cycles: one failing test, the minimal code to pass it, then cleanup under green. Use before writing production code for a new behavior, and whenever the request mentions TDD, test-driven, test-first, red-green-refactor, "write the test first", "start with a failing test", or reproducing a bug with a test before fixing it. Also use when implementation keeps landing before anyone knows how it will be verified. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
testing-agent-skills	Tests the customization assets themselves - skills, prompts, custom agents, instructions - the way a product is tested: activation cases that check an asset fires when it should and stays quiet when it should not, output-contract cases, safety cases, collision cases between assets competing for the same trigger, a weighted rubric scored blind, and a baseline-versus-candidate gate before an edit ships. Use when a skill is edited and nobody knows whether behaviour changed, when two skills fight over the same request, when a description is being tuned for discoverability, when a collection has grown past manual spot-checking, or when the request mentions skill evals, prompt regression, or "does this skill actually work". 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
testing-api-contracts	Validates API responses against OpenAPI or JSON Schema, detects breaking changes between spec versions, and builds consumer-driven contract checks. Use when an API has a published spec, when a backend change might break a client, when API tests assert only status codes, or when mocked fixtures need a guard against drifting from the real service. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
testing-application-security	Applies OWASP-informed security testing within a tester scope: an authorization gate before any probing, authorization matrices, broken access control and IDOR checks, input validation and injection observation, session and auth behaviour, and safe reporting of findings. Use when testing auth-protected features, when a security review needs QA coverage, when an exploratory session surfaced something security-shaped, or when access control needs a systematic check rather than a spot check. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
testing-llm-features	Builds an offline eval suite for LLM-powered features: golden reference cases per prompt template, deterministic scoring where possible, a regression gate on prompt, model and retrieval changes, and CI wiring with promptfoo, Vitest or deepeval. Use when a product ships prompts, agents or RAG, when a model or prompt upgrade needs a regression check, when LLM output is currently verified by someone eyeballing it, or when asked how to test a feature whose output is non-deterministic. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
testing-llm-guardrails	Tests the runtime validation around model output - schema conformance, PII leakage, moderation, refusal behaviour, tool-call safety - and the adversarial suite that tries to defeat it: direct prompt injection, jailbreaks, and indirect injection through retrieved documents, tool results and user content. Use when an LLM feature reaches real users, when a model can call tools or read untrusted content, when an AI feature needs a security-style test suite, or when asked whether a chatbot or agent can be manipulated. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
testing-performance-and-load	Designs and runs performance and load tests: workload modelling from real traffic, thresholds tied to SLOs, warmup and ramp shapes, percentile-based analysis, and lightweight CI perf checks with k6 or Artillery. Use when a feature has latency or throughput requirements, when "it feels slow" needs to become a number, when a launch needs a capacity check, or when a performance result needs interpreting rather than just collecting. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
tracing-requirements-to-code	Builds and maintains bidirectional traceability between requirements and the tests that verify them: extracts a matrix from an existing codebase, annotates tests with requirement IDs, finds orphan tests and uncovered requirements, verifies that each link is real, and enforces linkage in CI. Use when a suite exists but nobody can say what it proves, when an auditor or stakeholder asks which tests cover a requirement, when a traceability matrix has gone stale, or when a requirement changes and its blast radius must be found. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
tracking-quality-trends	Turns point-in-time quality readings into a trend: archives each run, diffs against the previous one, and reports direction per metric - practices newly present or regressed, coverage movement, flake rate, waivers expiring, eval scores - using limit/current/goal framing. Use when quality reporting is a series of disconnected snapshots, when a team needs to show improvement over a quarter, when a number is quoted with no baseline, or when a regression in the quality system itself should be visible. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
unslop-answers	Cuts AI tells from what the agent says about its own work: completion claimed without a run, invented file paths and API names, terminal output that was never produced, findings with no location, percentages with no denominator, absence claimed from one grep, effort narration instead of results, hedge stacking, buried blockers, puffery in a bug title. Use whenever reporting a result, a fix, a review finding, a test outcome, a coverage or flake number, a root cause, or a release recommendation, and when the request mentions "prove it", "did you actually run it", "be specific", "no fluff", "stop hedging", or "is this real". Must always apply to answers about your own work. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
unslop-tests	Cuts AI tells from test code: tests that pass without proving anything, tautological assertions, mock-only tests, hardcoded waits, coverage theater, vague names, swallowed errors, retries used as fixes. Use whenever test code is written, changed, or reviewed, including tests produced as a side effect of a feature task, and when the request mentions "review these tests", "are these tests any good", "this test always passes", "this suite is flaky", or "clean up these tests". Must always apply to test code. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
verifying-acceptance-criteria	Compares implementation evidence against acceptance criteria and shows what is met, partial, missing, or untestable. Use when checking feature readiness, preparing QA sign-off, or turning criteria into a concrete verification matrix without inventing missing behavior. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
verifying-change-coverage	Verifies that the lines and branches a change actually touched are executed by tests, using LCOV or Cobertura diff coverage instead of whole-repo percentages, and escalates uncovered high-risk changes into a blocking finding. Use when a pull request needs a coverage gate that unrelated tests cannot satisfy, when total coverage looks healthy but the diff is untested, when wiring diff coverage into CI, or when someone claims a change is covered because the suite is green. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual
writing-unit-tests-quick	Writes a few solid unit tests, using a compact set of rules for structure, assertions, determinism, and edge cases. Use for routine everyday testing of a single function, class, or small module, or for a quick sanity check on tests someone just wrote. For legacy backfills, flaky-suite investigations, deep test-double design, or a full suite review, use the writing-unit-tests skill instead.	manual
writing-unit-tests	Writes and reviews focused, deterministic unit tests that verify behavior through public interfaces instead of implementation details. Use whenever tests are added to code that already exists, and when the request mentions unit tests, test coverage, edge cases, mocks or test doubles, "add tests for this function", "cover this module", "these tests are flaky", or "this test breaks every refactor". Also use when reviewing an existing suite for brittleness, weak assertions, or missing boundary cases. 💡 Includes additional bundled resources in resources that should also be copied/used. See skill folder.	manual

Hooks

Hooks enable you to execute custom shell commands at key lifecycle points during agent sessions. Use hooks to automate workflows, enforce security policies, validate operations, and integrate with external tools. Hooks run deterministically and can control agent behavior, including blocking tool execution or injecting context into the conversation.

[!TIP] Usage:

• copy these hooks to your .github/hooks/ folder or .claude/settings.json

[!WARNING] Hooks are currently in preview and may require enabling experimental features in VS Code settings.

Title	Description	Install
Always-On Skills Hook	Keeps always-apply skill invariants in force across a session: materializes them into a workspace instructions file at session start, and restates the relevant one on stderr after each edit to a file in its scope.	Manual setup required
Print Tool Info Hook	Example hook that prints tool name, arguments, timestamp, and working directory before each tool call.	Manual setup required

Plugins

Plugins bundle skills (and other resources) into installable packages served from this repository's plugin marketplace (defined in .github/plugin/marketplace.json).

[!TIP] Usage:

copilot plugin marketplace add jaktestowac/awesome-copilot-for-testers
copilot plugin install <plugin-name>

The plugin skill copies under plugins/<plugin>/skills/ are generated from the skills/ directory, which is the source of truth. A plugin must ship its content self-contained (skill paths resolve relative to the plugin root, so a plugin cannot point up at skills/), which is why the copies exist.

Never edit them by hand. After changing anything under skills/, regenerate and verify:

npm run plugin:materialize
npm run lint

Each plugin declares what it ships in its .github/plugin/plugin.json ("skills": ["./skills/<name>/"]); the generator copies those from the repo root and prunes anything no longer declared.

Title	Description	Install
Analyzing Quality Metrics Plugin	Defines, computes, and interprets test and quality metrics: pass rate, flake rate, suite duration, defect escape rate, time to detect, and coverage with its caveats. Use when building a QA dashboard, reporting suite health to stakeholders, comparing releases over time, or when a coverage percentage or a bug count is being treated as a measure of quality.	copilot plugin install analyzing-quality-metrics
Analyzing Regression Scope Plugin	Analyzes diffs, changed files, hotfixes, and release candidates to identify where regression risk spreads and what must be retested first. Use when scoping retest after a change, reviewing QA impact for a pull request, or building a minimal confidence suite for release validation.	copilot plugin install analyzing-regression-scope
Api Playwright Test Developer Plugin	Writes and reviews API automation tests with Playwright Test, covering setup/teardown, assertions, data management, and hybrid API+UI flows. Use when creating backend API tests, contract checks, data-driven API coverage, API+UI hybrid workflows, or reviewing existing Playwright API suites.	copilot plugin install api-playwright-test-developer
Assessing Comprehension Debt Plugin	Measures the risk that code shipped without anyone understanding it: a teach-back attestation on high-risk changes, a risk band from changed-code complexity, diff size and whether a human explanation accompanied it, and optional AI-authorship provenance. Findings stay advisory by design. Use when an AI-assisted codebase grows faster than the team reads it, when reviews are rubber-stamped, when nobody can explain a module that ships weekly, or when leadership asks how much of the code the team can actually maintain.	copilot plugin install assessing-comprehension-debt
Assessing Release Readiness Plugin	Produces an evidence-backed go/no-go recommendation: exit criteria status, open-defect risk profile, coverage against risk, environment parity, rollback readiness, and the residual risk stated plainly. Use when preparing a release sign-off, when someone asks whether a build is ready to ship, or when a decision to release is being made on impressions rather than evidence.	copilot plugin install assessing-release-readiness
Attesting Manual Verification Plugin	Records human verification - code review, exploratory sessions, UAT, accessibility passes, UX and observability reviews - as dated, attributed attestations in a register, so human-centric practices stay in the quality contract without pretending to be automated checks. Use when a strategy requires verification no tool can prove, when sign-off evidence is scattered across chats and tickets, when a gap matrix needs to distinguish "attested" from "passed", or when an audit asks who verified what and when.	copilot plugin install attesting-manual-verification
Auditing Accessibility Plugin	Performs webpage and user-flow accessibility audits with WCAG 2.2 guidance, manual verification checklists, prioritized remediation output, and stakeholder-ready summaries. Use when auditing accessibility on a URL, triaging suspected a11y issues, or producing technical findings with practical next steps.	copilot plugin install auditing-accessibility
Code Review Plugin	Performs a quick, lightweight review of a small diff or single file, giving concise feedback on correctness, readability, tests, and obvious risks. Use when the user asks for a fast sanity-check review of a small change. For test-automation suites, architectural refactors, security-sensitive paths, or multi-file reviews, use the code-review-advanced skill instead.	copilot plugin install code-review
Code Review Advanced Plugin	Performs evidence-driven code review for pull requests, legacy modules, and quality-critical changes. Use when reviewing complex or multi-file changes, test automation suites, architectural refactors, or hot paths that need analysis of correctness, maintainability, security, performance, test quality, and operability risks. Provides structured feedback with severity-ranked findings, actionable recommendations, and clear rationale. For a fast sanity check of a small diff or single file, use the code-review skill instead.	copilot plugin install code-review-advanced
Creating Custom Agents Plugin	Creates GitHub Copilot custom agents (.agent.md) for VS Code. Use when defining a specialized agent role, selecting a minimal toolset, referencing supporting skills, or shipping install-ready agent examples with clear boundaries and collaboration rules.	copilot plugin install creating-custom-agents
Creating Hooks Plugin	Creates GitHub Copilot hooks for VS Code using hooks.json, supporting scripts, and companion docs. Use when automating deterministic checks, pre/post tool policies, or reusable hook packs that need safe defaults, observability, and clear installation guidance.	copilot plugin install creating-hooks
Creating Instructions Plugin	Creates GitHub Copilot instruction files for VS Code, including repository guidance and scoped .instructions.md rules. Use when encoding project conventions, choosing applyTo patterns, or shipping install-ready instruction examples with rationale and guardrails.	copilot plugin install creating-instructions
Creating Orchestration Packs Plugin	Creates agent orchestration packs: cooperating .agent.md files with an orchestrator, subagents, matched handoffs, minimal tool grants, and a shared handoff packet contract. Use when one agent role is too broad for a job, when a workflow needs explore, plan, implement, review, and verify as separate roles, or when a pack fails the orchestration lint because a handoff target does not resolve.	copilot plugin install creating-orchestration-packs
Creating Plugins Plugin	Packages repository skills as installable Copilot plugins: marketplace registration, plugin.json manifests, generated skill copies, and the sync check CI enforces. Use when bundling one or more skills for installation, when adding a plugin to the marketplace, or when npm run lint reports that a plugin copy has drifted from its source skill.	copilot plugin install creating-plugins
Creating Prompts Plugin	Creates GitHub Copilot prompt files (.prompt.md) for VS Code. Use when building reusable workflow starters that route work to the right agent, collect the right inputs, and ship with install-ready templates, examples, and validation guidance.	copilot plugin install creating-prompts
Creating Skills Plugin	Creates GitHub Copilot skills with reusable workflows, companion resources, and validation gates. Use when packaging repeatable expertise into a SKILL.md folder, deciding what belongs in the skill body versus resources, or producing install-ready skill examples for a team or collection.	copilot plugin install creating-skills
Deriving A Quality Contract Plugin	Derives a project-specific quality contract from three axes — risk profile, team maturity, and product surface — labelling each testing practice MUST, SHOULD, or COULD, then produces a PRESENT/PARTIAL/MISSING/WAIVED gap matrix with an ordered remediation plan. Use when a project has no agreed testing strategy, when a team argues about which practices are mandatory, when onboarding a legacy or inherited repository, when a quality strategy document has to be derived from evidence instead of opinion, or when someone asks "what testing should we actually be doing here".	copilot plugin install deriving-a-quality-contract
Designing Functional Tests Plugin	Designs risk-based functional test plans, manual test cases, regression slices, and automation handoff packs from requirements, URLs, or exploratory notes. Use when preparing manual QA coverage before automation, turning feature descriptions into scenario catalogs, or converting exploratory findings into structured test assets.	copilot plugin install designing-functional-tests
Designing Test Data Plugin	Designs realistic, boundary-heavy, and role-aware test data packs for manual and automated testing. Use when a feature needs deliberate inputs and fixtures before execution, when edge-case values keep being improvised, or when automation needs stable example data with setup notes.	copilot plugin install designing-test-data
Documenting Test Suites Plugin	Writes the documentation a test suite needs to be usable by someone who did not build it: run instructions, environment setup, tag glossary, ownership, fixture and data notes, and architecture decision records. Use when onboarding someone into a suite, when "how do I run these" keeps being asked, when a test architecture decision needs recording, or when a suite is inherited with no documentation.	copilot plugin install documenting-test-suites
Generating Quality Gate Workflows Plugin	Generates the CI workflow that enforces a quality contract: layered jobs from fast local hooks to release gates, per-practice steps for JS/TS toolchains, diff-scoped checks, sticky PR reporting, required-check wiring, and a severity policy deciding what fails the build. Use when quality practices are agreed but not enforced, when CI runs everything on every commit, when a gate reports green while the check it runs cannot fail, or when a per-change gate needs to post findings on the pull request.	copilot plugin install generating-quality-gate-workflows
Governing Quality Waivers Plugin	Turns "we will skip this check for now" into a dated, attributed, expiring waiver with a stated reason and owner, inventories the silent skips already hiding in a repo - skipped tests, disabled lint rules, ts-expect-error, continue-on-error, lowered thresholds, coverage ignores - and reports expired waivers as findings. Use when a team wants to bypass a quality gate, when skip lists and quarantined tests accumulate without owners, when an audit asks why a check is off, or when a repo needs to know what it has quietly stopped enforcing.	copilot plugin install governing-quality-waivers
Handling Sensitive Test Data Plugin	Keeps test data legally and operationally safe: classifies personal data, replaces production copies with synthetic or anonymized fixtures, manages secrets in local runs and CI, strips personal data from traces and HAR files, and sets retention rules. Use when tests run against a production data copy, when fixtures contain real names or emails, when a data protection review is coming, or when test artifacts might carry personal data into CI logs.	copilot plugin install handling-sensitive-test-data
Migrating Tests To Playwright Plugin	Migrates Cypress, Selenium, WebdriverIO, or Protractor suites to Playwright in staged slices, each with a parity gate before the old test is deleted. Use when porting a legacy browser suite, when deciding which tests are not worth porting, when a half-finished migration has stalled with two suites running in parallel, or when a suite migration needs a plan before anyone starts translating files.	copilot plugin install migrating-tests-to-playwright
Mocking Network And Time Plugin	Decides what to fake and stubs it correctly: network interception with Playwright route or HAR replay, MSW handlers, fake clocks, and fixed timezones. Use when a test depends on a third party, when a date-sensitive test breaks overnight, when a suite is slow because it calls real services, or when a mocked test stays green while production is broken.	copilot plugin install mocking-network-and-time
Planning Exploratory Testing Plugin	Runs session-based exploratory testing: writes charters, timeboxes sessions, applies coverage heuristics and tours, captures notes as evidence, debriefs, and converts findings into bug reports and automation candidates. Use when a feature needs testing before requirements settle, when scripted cases keep passing while users hit problems, when a release needs a risk sweep with limited time, or when the request mentions charters or exploratory sessions.	copilot plugin install planning-exploratory-testing
Prd Generator Plugin	Produces production-ready Product Requirements Documents (PRDs) for software systems and AI-powered features, with clear problem framing, measurable outcomes, scoped functionality, testable requirements, and explicit risks. Use when the user wants to write a PRD, define requirements, plan a feature, or turn a vague product idea into an implementation-ready specification.	copilot plugin install prd-generator
Recording Change Intent Plugin	Requires an externalised rationale for high-risk changes — new public exports, new endpoints, auth edits, migrations, removed guards — recorded as an Intent commit trailer, an ADR reference, or a module intent register, and reports high-risk changes that carry none. Use when agent-generated or AI-assisted changes ship without a recorded why, when reviewers cannot tell what a diff was for, when a codebase is losing its decision history, or when setting up an intent gate alongside test and coverage gates.	copilot plugin install recording-change-intent
Reporting Bugs Plugin	Transforms rough tester notes, screenshots, console output, or observed behavior into reproducible defect reports with severity, evidence, and follow-up guidance. Use when logging bugs, triaging intermittent issues, or rewriting vague defect notes into developer-ready reports.	copilot plugin install reporting-bugs
Requirements Test Coverage Mapper Plugin	Maps requirements (PRD, user stories, acceptance criteria) to planned test coverage via a Requirements Traceability Matrix, exposing coverage gaps, risks, test levels, prioritization, and automation candidates. Use when designing coverage from a specification, checking coverage completeness for a PRD or user story, finding missing acceptance criteria, or building a risk-based regression strategy. When the tests already exist and the matrix has to be extracted from them, verified, and kept accurate, use the tracing-requirements-to-code skill instead.	copilot plugin install requirements-test-coverage-mapper
Reviewing AI Output Groundedness Plugin	Human review protocol for whether AI output is grounded in its sources: claim-by-claim attribution, hallucination classes, citation verification, sampling that is defensible, and a recorded attestation because groundedness cannot be fully automated. Also covers the responsible-AI pass — harmful output, bias, disclosure and privacy. Use when reviewing a RAG or summarisation feature, when factuality matters more than fluency, or when an eval suite needs the human check it cannot replace.	copilot plugin install reviewing-ai-output-groundedness
Running Visual Regression Tests Plugin	Sets up and maintains visual regression testing: what to snapshot, baseline strategy, masking dynamic regions, threshold tuning, containerized baselines, and the review-and-update workflow. Use when styling regressions escape to production, when snapshots fail on every machine or every run, when baselines are being updated without being looked at, or when deciding whether visual testing is the right tool at all.	copilot plugin install running-visual-regression-tests
Scoping Change Relevance Plugin	Classifies a diff into file tags and hunk tags — new public export, new endpoint, modified auth, SQL string, migration, added dependency, touched prompt — then maps each tag to the quality practices it makes relevant, producing a defensible per-change check scope instead of running everything or guessing. Use when deciding what to test for a specific pull request, when a full regression run is too slow to gate on, when a pre-push or PR gate needs a scope someone can argue with, or when asked "which checks does this change actually need".	copilot plugin install scoping-change-relevance
Static Code Analysis Typescript Plugin	Creates, reviews, and modernizes static code analysis setups for Node.js and TypeScript repositories, covering ESLint flat config, typescript-eslint, tsconfig, Prettier, import sorting, Husky, lint-staged, package.json quality scripts, and CI quality gates. Use when setting up or auditing linting, formatting, type-checking, commit hooks, or GitHub Actions quality checks in a TypeScript project.	copilot plugin install static-code-analysis-typescript
Tech Debt Analysis Plugin	Analyzes technical debt in codebases, test suites, architecture, dependencies, and delivery workflows using observable signals. Use when auditing repository health, explaining slow delivery or flaky tests, prioritizing refactoring, or building an evidence-based remediation roadmap with risk, effort, and ROI. Use when user asks for technical debt analysis, repository audit, or refactor planning.	copilot plugin install tech-debt-analysis
Test Driven Development Plugin	Drives implementation test-first through red-green-refactor cycles: one failing test, the minimal code to pass it, then cleanup under green. Use before writing production code for a new behavior, and whenever the request mentions TDD, test-driven, test-first, red-green-refactor, "write the test first", "start with a failing test", or reproducing a bug with a test before fixing it. Also use when implementation keeps landing before anyone knows how it will be verified.	copilot plugin install test-driven-development
Testing Api Contracts Plugin	Validates API responses against OpenAPI or JSON Schema, detects breaking changes between spec versions, and builds consumer-driven contract checks. Use when an API has a published spec, when a backend change might break a client, when API tests assert only status codes, or when mocked fixtures need a guard against drifting from the real service.	copilot plugin install testing-api-contracts
Testing Application Security Plugin	Applies OWASP-informed security testing within a tester scope: an authorization gate before any probing, authorization matrices, broken access control and IDOR checks, input validation and injection observation, session and auth behaviour, and safe reporting of findings. Use when testing auth-protected features, when a security review needs QA coverage, when an exploratory session surfaced something security-shaped, or when access control needs a systematic check rather than a spot check.	copilot plugin install testing-application-security
Testing LLM Features Plugin	Builds an offline eval suite for LLM-powered features: golden reference cases per prompt template, deterministic scoring where possible, a regression gate on prompt, model and retrieval changes, and CI wiring with promptfoo, Vitest or deepeval. Use when a product ships prompts, agents or RAG, when a model or prompt upgrade needs a regression check, when LLM output is currently verified by someone eyeballing it, or when asked how to test a feature whose output is non-deterministic.	copilot plugin install testing-llm-features
Testing LLM Guardrails Plugin	Tests the runtime validation around model output — schema conformance, PII leakage, moderation, refusal behaviour, tool-call safety — and the adversarial suite that tries to defeat it: direct prompt injection, jailbreaks, and indirect injection through retrieved documents, tool results and user content. Use when an LLM feature reaches real users, when a model can call tools or read untrusted content, when an AI feature needs a security-style test suite, or when asked whether a chatbot or agent can be manipulated.	copilot plugin install testing-llm-guardrails
Testing Performance And Load Plugin	Designs and runs performance and load tests: workload modelling from real traffic, thresholds tied to SLOs, warmup and ramp shapes, percentile-based analysis, and lightweight CI perf checks with k6 or Artillery. Use when a feature has latency or throughput requirements, when "it feels slow" needs to become a number, when a launch needs a capacity check, or when a performance result needs interpreting rather than just collecting.	copilot plugin install testing-performance-and-load
Tracing Requirements To Code Plugin	Builds and maintains bidirectional traceability between requirements and the tests that verify them: extracts a matrix from an existing codebase, annotates tests with requirement IDs, finds orphan tests and uncovered requirements, verifies that each link is real, and enforces linkage in CI. Use when a suite exists but nobody can say what it proves, when an auditor or stakeholder asks which tests cover a requirement, when a traceability matrix has gone stale, or when a requirement changes and its blast radius must be found.	copilot plugin install tracing-requirements-to-code
Tracking Quality Trends Plugin	Turns point-in-time quality readings into a trend: archives each run, diffs against the previous one, and reports direction per metric — practices newly present or regressed, coverage movement, flake rate, waivers expiring, eval scores — using limit/current/goal framing. Use when quality reporting is a series of disconnected snapshots, when a team needs to show improvement over a quarter, when a number is quoted with no baseline, or when a regression in the quality system itself should be visible.	copilot plugin install tracking-quality-trends
Unslop Answers Plugin	Cuts AI tells from what the agent says about its own work: completion claimed without a run, invented file paths and API names, terminal output that was never produced, findings with no location, percentages with no denominator, absence claimed from one grep, effort narration instead of results, hedge stacking, buried blockers, puffery in a bug title. Use whenever reporting a result, a fix, a review finding, a test outcome, a coverage or flake number, a root cause, or a release recommendation, and when the request mentions "prove it", "did you actually run it", "be specific", "no fluff", "stop hedging", or "is this real". Must always apply to answers about your own work.	copilot plugin install unslop-answers
Unslop Tests Plugin	Cuts AI tells from test code: tests that pass without proving anything, tautological assertions, mock-only tests, hardcoded waits, coverage theater, vague names, swallowed errors, retries used as fixes. Use whenever test code is written, changed, or reviewed, including tests produced as a side effect of a feature task, and when the request mentions "review these tests", "are these tests any good", "this test always passes", "this suite is flaky", or "clean up these tests". Must always apply to test code.	copilot plugin install unslop-tests
Verifying Acceptance Criteria Plugin	Compares implementation evidence against acceptance criteria and shows what is met, partial, missing, or untestable. Use when checking feature readiness, preparing QA sign-off, or turning criteria into a concrete verification matrix without inventing missing behavior.	copilot plugin install verifying-acceptance-criteria
Verifying Change Coverage Plugin	Verifies that the lines and branches a change actually touched are executed by tests, using LCOV or Cobertura diff coverage instead of whole-repo percentages, and escalates uncovered high-risk changes into a blocking finding. Use when a pull request needs a coverage gate that unrelated tests cannot satisfy, when total coverage looks healthy but the diff is untested, when wiring diff coverage into CI, or when someone claims a change is covered because the suite is green.	copilot plugin install verifying-change-coverage
Writing Unit Tests Plugin	Writes and reviews focused, deterministic unit tests that verify behavior through public interfaces instead of implementation details. Use whenever tests are added to code that already exists, and when the request mentions unit tests, test coverage, edge cases, mocks or test doubles, "add tests for this function", "cover this module", "these tests are flaky", or "this test breaks every refactor". Also use when reviewing an existing suite for brittleness, weak assertions, or missing boundary cases.	copilot plugin install writing-unit-tests

📚 Additional Resources

• VS Code Copilot Customization Documentation - Official Microsoft documentation
• GitHub Copilot Chat Documentation - Complete chat feature guide
• Custom Chat Modes - Advanced chat configuration
• Custom Instructions - Customize Copilot's behavior
• Prompt Files - Using prompt templates
• Custom Agents - Advanced agent configuration
• Agent Orchestration - Coordinating multiple agents for complex workflows
• Agent Skills - Extend agent capabilities with custom skills
• Hooks - Automate actions based on chat events
• VS Code Settings - General VS Code configuration guide
• Using agents in Visual Studio Code - Overview of agents and orchestration
• Subagents in Visual Studio Code - Using subagents for specialized tasks
• Agent Skills - open standard - Specification and documentation for Agent Skills

🌱 Contributing

Are you interested in contributing to this project?

We welcome your contributions! Whether it's adding new instructions, prompts, or chat modes, your input is valuable.

Just follow the Contributing Guidelines to get started!

📞 Contact & Support

Feel free to reach out to us:

• 🌐 Website: jaktestowac.pl
• 💼 LinkedIn: jaktestowac.pl
• 💬 Discord: Polish Playwright Community
• 📧 Support: Check our website for contact details

---

📚 Learning Resources

We have gathered a collection of resources to help you learn and master Playwright, both in Polish and English. Whether you're a beginner or an advanced user, these resources will help you enhance your skills and knowledge.

🇵🇱 Polish Resources

• 💡 FREE Playwright Resources - Comprehensive and Free Polish learning materials
• JavaScript and TypeScript for Testers - Comprehensive (13h+) course on JavaScript and TypeScript for testers, with practical examples and exercises
• Professional Test Automation with Playwright - Comprehensive (100h+) course on Playwright, test automation, CI/CD and test architecture
• Back-end Test Automation - Comprehensive (45h+) course on Back-end Test Automation with Postman, Mocha, Chai, and Supertest
• Playwright Basics - YouTube series (Polish)
• Playwright Elements - Advanced concepts (Polish)
• Playwright MCP - MCP course (Polish)
• Discord Community - First Polish Playwright community!
• Playwright Info - first and only Polish Playwright blog

AI_Testers

Gain an edge by combining AI knowledge with the most popular tools in the IT market.
We'll show you how to accelerate with AI and build a professional test automation framework. 😉

• AI_Testers - Main page about AI_Testers Program
• AI_Testers LinkedIn - Follow us on LinkedIn

🇬🇧 English Resources

• VS Code Extensions - Our free Playwright plugins
• Playwright Documentation - Official documentation
• Playwright GitHub - Source code and issues

PS. For more resources and updates, follow us on our website and GitHub.

---

Happy testing and automation! 🚀

jaktestowac.pl Team ❤️💚

Built with ❤️💚 for the Playwright and test automation community