Polyglot Test Agent
Run a Research → Plan → Implement pipeline to add unit tests that compile, pass, and match project conventions across many languages.
Overview
polyglot-test-agent is an agent skill most often used in Ship (also Build backend and Operate iterate) that orchestrates research, planning, and implementation to produce compiling, passing unit tests across many program
Install
npx skills add https://github.com/github/awesome-copilot --skill polyglot-test-agentWhat is this skill?
- Multi-agent pipeline: Research → Plan → Implement coordinated by a test generator
- Explicit triggers: generate tests, improve coverage, add test files, test a codebase
- Supports C#, TypeScript, JavaScript, Python, Go, Rust, Java, and more
- Aims for tests that compile, pass, and follow project conventions
- Works at project-wide or single-file scope
- 3-phase pipeline: Research → Plan → Implement
- 8+ languages called out including C#, TypeScript, Python, Go, and Rust
Adoption & trust: 8.5k installs on skills.sh; 34.6k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You need better test coverage but your agent writes tests that ignore framework patterns, fail to compile, or do not match how the repo already tests.
Who is it for?
Polyglot codebases and indies shipping features who want agent-driven test generation with a deliberate research-and-plan gate before writing files.
Skip if: Pure manual TDD coaching, E2E-only suites, or repos where you forbid automated multi-file test edits without human review.
When should I use this skill?
Asked to generate tests, write unit tests, improve test coverage, add test coverage, create test files, or test a codebase.
What do I get? / Deliverables
New or expanded test files aligned to project conventions, produced through a documented three-phase agent pipeline with compile-and-pass intent.
- New or updated unit test files per project conventions
- Pipeline plan artifact implied by Research and Plan phases before Implement
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Primary shelf is Ship testing because the skill exists to improve coverage and produce workable test files before release. Orchestrates specialized agents to research conventions, plan test targets, then implement tests—not a one-shot snippet generator.
Where it fits
New API handlers merged without tests—the pipeline researches existing xUnit or pytest patterns then adds matching unit tests.
Pre-release pass to raise coverage on critical modules with tests that are planned before implementation writes files.
After a production bug fix, generate focused tests around the patched module so regressions are caught in CI.
How it compares
Orchestrated test-generation workflow—not a single-language snippet cheat sheet or production monitoring skill.
Common Questions / FAQ
Who is polyglot-test-agent for?
Solo builders and small teams on Claude Code, Cursor, or Codex who maintain multi-language repos and want structured agent help for unit tests and coverage.
When should I use polyglot-test-agent?
Use it in Ship testing before release, in Build when landing untested features, or in Operate iterate when hardening bugs fixes—especially when asked to generate tests, improve coverage, or add test files.
Is polyglot-test-agent safe to install?
It drives multi-step agents that read and write test sources; review the Security Audits panel on this page and run the pipeline on a branch with CI you trust.
SKILL.md
READMESKILL.md - Polyglot Test Agent
# Polyglot Test Generation Skill An AI-powered skill that generates comprehensive, workable unit tests for any programming language using a coordinated multi-agent pipeline. ## When to Use This Skill Use this skill when you need to: - Generate unit tests for an entire project or specific files - Improve test coverage for existing codebases - Create test files that follow project conventions - Write tests that actually compile and pass - Add tests for new features or untested code ## How It Works This skill coordinates multiple specialized agents in a **Research → Plan → Implement** pipeline: ### Pipeline Overview ``` ┌─────────────────────────────────────────────────────────────┐ │ TEST GENERATOR │ │ Coordinates the full pipeline and manages state │ └─────────────────────┬───────────────────────────────────────┘ │ ┌─────────────┼─────────────┐ ▼ ▼ ▼ ┌───────────┐ ┌───────────┐ ┌───────────────┐ │ RESEARCHER│ │ PLANNER │ │ IMPLEMENTER │ │ │ │ │ │ │ │ Analyzes │ │ Creates │ │ Writes tests │ │ codebase │→ │ phased │→ │ per phase │ │ │ │ plan │ │ │ └───────────┘ └───────────┘ └───────┬───────┘ │ ┌─────────┬───────┼───────────┐ ▼ ▼ ▼ ▼ ┌─────────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ BUILDER │ │TESTER │ │ FIXER │ │LINTER │ │ │ │ │ │ │ │ │ │ Compiles│ │ Runs │ │ Fixes │ │Formats│ │ code │ │ tests │ │ errors│ │ code │ └─────────┘ └───────┘ └───────┘ └───────┘ ``` ## Step-by-Step Instructions ### Step 1: Determine the User Request Make sure you understand what user is asking and for what scope. When the user does not express strong requirements for test style, coverage goals, or conventions, source the guidelines from [unit-test-generation.prompt.md](unit-test-generation.prompt.md). This prompt provides best practices for discovering conventions, parameterization strategies, coverage goals (aim for 80%), and language-specific patterns. ### Step 2: Invoke the Test Generator Start by calling the `polyglot-test-generator` agent with your test generation request: ``` Generate unit tests for [path or description of what to test], following the [unit-test-generation.prompt.md](unit-test-generation.prompt.md) guidelines ``` The Test Generator will manage the entire pipeline automatically. ### Step 3: Research Phase (Automatic) The `polyglot-test-researcher` agent analyzes your codebase to understand: - **Language & Framework**: Detects C#, TypeScript, Python, Go, Rust, Java, etc. - **Testing Framework**: Identifies MSTest, xUnit, Jest, pytest, go test, etc. - **Project Structure**: Maps source files, existing tests, and dependencies - **Build Commands**: Discovers how to build and test the project Output: `.testagent/research.md` ### Step 4: Planning Phase (Automatic) The `polyglot-test-planner` agent creates a structured implementation plan: - Groups files into logical phases (2-5 phases typical) - Prioritizes by complexity and dependencies - Specifies test cases for each file - Defines success criteria per phase Output: `.testagent/plan.md` ### Step 5: Implementation Phase (Automatic) The `polyglot-test-implementer` agent execu