MMCPMarkets
JA

jaktestowac/awesome-copilot-for-testers

Developer tools
112 stars 품질 70 트렌드 70
Repository Install

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...

개요

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...

README

🤖 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:

[!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

[!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:

[!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.
Playwright E2E rules Playwright E2E test rules: test intent, isolation, locator strategy, waiting discipline, flake prevention, and diagnostics.
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.
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.
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 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.
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.
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.
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.
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 ->
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).
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.
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.
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:

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.

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/
    └── /
        ├── SKILL.md
        └── resources/
            └── example.txt

where `` 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-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
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
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-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
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
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
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 test coverage via a Requirements Traceability Matrix, exposing coverage gaps, risks, test levels, prioritization, and automation candidates. Use when mapping requirements to tests, checking coverage completeness for a PRD or user story, finding missing acceptance criteria, or building a risk-based regression strategy. 💡 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
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
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
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

The plugin skill copies under plugins//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//"]); the generator copies those from the repo root and prunes anything no longer declared.

Title Description Install
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
Requirements Test Coverage Mapper Plugin Plugin that maps requirements (PRD, user stories, acceptance criteria) to test coverage via a Requirements Traceability Matrix, exposing gaps, risks, and automation candidates. copilot plugin install requirements-test-coverage-mapper
Tech Debt Analysis Plugin Plugin that analyzes a codebase for technical debt, identifies areas for improvement, and generates actionable, prioritized insights to enhance code quality and maintainability. 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. Bundles the full workflow — loop shape, green-step strategies, bug reproduction, legacy entry, a worked example, and a cycle log — together with a compact quick version for routine single-behavior cycles. Framework-agnostic: no runner, assertion library, or mocking tool is assumed. copilot plugin install test-driven-development
Writing Unit Tests Plugin Writes and reviews focused, deterministic unit tests that verify behavior through public interfaces instead of implementation details. Bundles the full workflow — test-level choice, case design, determinism control, test doubles, legacy characterization, and a review checklist — together with a compact quick version for routine everyday testing. Framework-agnostic: no runner, assertion library, or mocking tool is assumed. copilot plugin install writing-unit-tests

📚 Additional Resources

🌱 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:

📚 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

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. 😉

🇬🇧 English Resources

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

View this README on GitHub

추천 도구

다른 키워드를 입력하거나 필터를 제거해 보세요.

설치

npx skillfish add jaktestowac/awesome-copilot-for-testers