test-agent-skill

Generate RED-phase test suites for PRD-driven features using Vitest, Playwright, and Zod.

Updated Sep 29, 2025
One-click install
npx skills add https://github.com/fercracix33/poli2-clean-architecture --skill test-agent-skill
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: test-agent-skill
Source: https://github.com/fercracix33/poli2-clean-architecture/tree/main/.claude/skills/test-agent-skill
Command: npx skills add https://github.com/fercracix33/poli2-clean-architecture --skill test-agent-skill

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill eliminates ambiguity in software development by creating comprehensive failing test suites that serve as the definitive specification before implementation begins.

Core Features & Use Cases

  • TDD Workflow: Guide through creating failing test suites across all architectural layers (entities, use cases, services, APIs, E2E) using Vitest, Playwright, and Testing Library.
  • Use Case: After receiving requirements from an Architect, use this Skill to create test suites that fail appropriately, proving no implementation exists yet while defining exactly what must be built.

Quick Start

Use the test-agent-skill to create a comprehensive failing test suite for the new user authentication feature based on the PRD documentation.

Technical Requirements

  • Mandatory Context7 consultation for latest testing patterns
  • Comprehensive coverage across entities, use cases, services, APIs, and E2E workflows All tests must fail initially with "not defined" or "not implemented" errors

Frequently Asked Questions about test-agent-skill

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I create failing test suites that define specifications before writing code?

Test-driven development (TDD) uses failing tests as executable specifications. This Skill generates comprehensive RED-phase test suites using Vitest, Playwright, and Testing Library that intentionally fail to prove no implementation exists yet, establishing immutable requirements across entities, use cases, services, APIs, and end-to-end flows before implementation begins.

Can I use Vitest and Playwright together for full-stack test coverage?

Yes. This Skill orchestrates Vitest for unit and integration testing, Playwright for end-to-end browser testing, and Testing Library for component testing, covering all architectural layers in a unified TDD workflow with mandatory Context7 pattern consultation and strict RED-phase failure guarantees.

What's the best way to structure test suites across multiple architectural layers?

Organize tests by architectural tier—entities, use cases, services, APIs, and E2E flows—using template-driven test creation. This Skill enforces this layered approach with Zod schemas for validation, coverage configuration, and mock infrastructure, ensuring comprehensive specification coverage from Phase 0 research through Phase 6 handoff.

Do I need to write test specifications manually, or can they be generated?

This Skill generates comprehensive test specifications from PRD-driven feature requirements, eliminating manual ambiguity. It produces template-driven test suites that fail intentionally with 'not defined' or 'not implemented' errors, serving as the definitive specification without requiring manual specification writing.

How do I ensure tests fail correctly before implementation?

This Skill enforces strict RED-phase failure guarantees through mandatory research, template-driven test creation, and mock infrastructure setup. Tests are validated to fail with appropriate 'not defined' or 'not implemented' errors, proving the specification is defined and implementation does not yet exist.

What happens after I create failing test suites?

After RED-phase test creation, implementation follows the test specifications through Phases 1–6. The immutable failing tests guide development and serve as acceptance criteria, ensuring the final implementation matches the originally defined specification exactly.