testing-gate
Gate 6 - Verify tests exist and cover critical paths. Issues result in WARNINGS (encourages tests, doesn't block).
Best use case
testing-gate is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Gate 6 - Verify tests exist and cover critical paths. Issues result in WARNINGS (encourages tests, doesn't block).
Teams using testing-gate should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/testing-gate/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How testing-gate Compares
| Feature / Agent | testing-gate | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Gate 6 - Verify tests exist and cover critical paths. Issues result in WARNINGS (encourages tests, doesn't block).
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Gate 6: Testing Verification > "Tests are proof of understanding. If you can't test it, do you really understand it?" ## Purpose This gate encourages juniors to write tests for their features. Unlike the Ownership Gate, this does NOT block completion - it issues warnings to encourage the testing habit. ## Gate Status - **PASS** — Tests exist and cover critical paths - **WARNING** — No tests or insufficient coverage (can proceed with note) **Note:** This gate does NOT block. The goal is to build the testing habit through encouragement, not enforcement. --- ## Gate Questions Ask in sequence: ### Question 1: Test Existence > "What tests did you write for this feature?" **Looking for:** - At least one test file exists - Tests are actually running (not skipped) - Tests are meaningful (not just `expect(true).toBe(true)`) **If no tests:** > "I noticed there aren't tests for this feature. Testing isn't required to complete, but it's a habit worth building. What would you test if you had time?" ### Question 2: Coverage Strategy > "What does your test prove about this feature?" **Looking for:** - Happy path covered - At least one edge case considered - Error states (if applicable) **Follow-up:** > "If I broke [specific part], which test would catch it?" ### Question 3: Test Quality > "Show me your most important test. What behavior does it verify?" **Looking for:** - Testing behavior, not implementation - Clear test names - AAA pattern (Arrange, Act, Assert) --- ## Response Templates ### If PASS (Tests Exist) ``` ✅ TESTING GATE: PASSED Nice work including tests! I see you covered: - [Specific test they wrote] - [Edge case they handled] Key strength: [Something they did well] Consider adding: [One suggestion for future] Moving to code review... ``` ### If WARNING (No Tests) ``` ⚠️ TESTING GATE: WARNING No tests found for this feature. That's okay - we can proceed. But here's why tests matter: 1. **Interview Gold**: "I implemented tests for critical flows..." 2. **Confidence**: Know your changes don't break things 3. **Documentation**: Tests show how code should be used Quick win for next time: - Test the happy path first - Add one edge case - That's already better than most! Proceeding to code review... ``` ### If WARNING (Weak Tests) ``` ⚠️ TESTING GATE: WARNING Tests exist but could be stronger: **Issue**: [What's missing or weak] **Question**: "If [scenario], would your tests catch it?" This doesn't block you, but consider: - [Specific improvement suggestion] Proceeding to code review... ``` --- ## What Makes a Good Test Suite? | Level | Coverage | Characteristics | |-------|----------|-----------------| | Minimal | 1-2 tests | Happy path only | | Good | 3-5 tests | Happy path + main edge cases | | Strong | 5-10 tests | Happy path + edge cases + error states | | Interview-Ready | Full pyramid | Unit + Integration + E2E for critical flows | --- ## Socratic Guidance If they want to add tests but don't know where to start: 1. "What's the ONE thing that would be really bad if it broke?" 2. "What input would a user never send but a hacker might?" 3. "What happens when the server is slow or returns an error?" --- ## Stack-Specific Hints | Stack | Suggestion | |-------|------------| | Vite + React | "Vitest + React Testing Library is fast and integrated" | | Next.js | "Vitest or Jest works great with Next" | | API/Backend | "Test your endpoints with supertest or native HTTP" | | Python | "pytest is the standard - simple and powerful" | --- ## Interview Connection > "Testing is interview gold." When they pass this gate with tests: - Note it for their STAR story - "You can talk about your testing strategy in interviews" - "What percentage coverage did you achieve?" (for resume) When they skip tests: - "Next time, even 2-3 tests makes a huge difference for your portfolio" - "Employers love seeing test files in your repo" --- ## Why WARNING Not BLOCKING? 1. **Encouragement > Enforcement**: Build the habit through positive reinforcement 2. **Some features are trivial**: Not everything needs tests 3. **Time constraints exist**: Production pressure is real 4. **Learning curve**: Testing has a learning curve; don't block progress The goal is to make testing feel valuable, not punitive.
Related Skills
performing-visual-regression-testing
This skill enables Claude to execute visual regression tests using tools like Percy, Chromatic, and BackstopJS. It captures screenshots, compares them against baselines, and analyzes visual differences to identify unintended UI changes. Use this skill when the user requests visual testing, UI change verification, or regression testing for a web application or component. Trigger phrases include "visual test," "UI regression," "check visual changes," or "/visual-test".
performing-security-testing
This skill automates security vulnerability testing. It is triggered when the user requests security assessments, penetration tests, or vulnerability scans. The skill covers OWASP Top 10 vulnerabilities, SQL injection, XSS, CSRF, authentication issues, and authorization flaws. Use this skill when the user mentions "security test", "vulnerability scan", "OWASP", "SQL injection", "XSS", "CSRF", "authentication", or "authorization" in the context of application or API testing.
performance-testing
This skill enables Claude to design, execute, and analyze performance tests using the performance-test-suite plugin. It is activated when the user requests load testing, stress testing, spike testing, or endurance testing, and when discussing performance metrics such as response time, throughput, and error rates. It identifies performance bottlenecks related to CPU, memory, database, or network issues. The plugin provides comprehensive reporting, including percentiles, graphs, and recommendations.
performing-penetration-testing
This skill enables automated penetration testing of web applications. It uses the penetration-tester plugin to identify vulnerabilities, including OWASP Top 10 threats, and suggests exploitation techniques. Use this skill when the user requests a "penetration test", "pentest", "vulnerability assessment", or asks to "exploit" a web application. It provides comprehensive reporting on identified security flaws.
automating-mobile-app-testing
This skill enables automated testing of mobile applications on iOS and Android platforms using frameworks like Appium, Detox, XCUITest, and Espresso. It generates end-to-end tests, sets up page object models, and handles platform-specific elements. Use this skill when the user requests mobile app testing, test automation for iOS or Android, or needs assistance with setting up device farms and simulators. The skill is triggered by terms like "mobile testing", "appium", "detox", "xcuitest", "espresso", "android test", "ios test".
load-testing-apis
Execute comprehensive load and stress testing to validate API performance and scalability. Use when validating API performance under load. Trigger with phrases like "load test the API", "stress test API", or "benchmark API performance".
testing-load-balancers
This skill enables Claude to test load balancing strategies. It validates traffic distribution across backend servers, tests failover scenarios when servers become unavailable, verifies sticky sessions, and assesses health check functionality. Use this skill when the user asks to "test load balancer", "validate traffic distribution", "test failover", "verify sticky sessions", or "test health checks". It is specifically designed for testing load balancing configurations using the `load-balancer-tester` plugin.
managing-database-testing
This skill manages database testing by generating test data, wrapping tests in transactions, and validating database schemas. It is used to create robust and reliable database interactions. Claude uses this skill when the user requests database testing utilities, including test data generation, transaction management, schema validation, or migration testing. Trigger this skill by mentioning "database testing," "test data factories," "transaction rollback," "schema validation," or using the `/db-test` or `/dbt` commands.
building-api-gateway
Create API gateways with routing, load balancing, rate limiting, and authentication. Use when routing and managing multiple API services. Trigger with phrases like "build API gateway", "create API router", or "setup API gateway".
backtesting-trading-strategies
Backtest crypto and traditional trading strategies against historical data. Calculates performance metrics (Sharpe, Sortino, max drawdown), generates equity curves, and optimizes strategy parameters. Use when user wants to test a trading strategy, validate signals, or compare approaches. Trigger with phrases like "backtest strategy", "test trading strategy", "historical performance", "simulate trades", "optimize parameters", or "validate signals".
api-testing-helper
Api Testing Helper - Auto-activating skill for API Development. Triggers on: api testing helper, api testing helper Part of the API Development skill category.
automating-api-testing
This skill automates API endpoint testing, including request generation, validation, and comprehensive test coverage for REST and GraphQL APIs. It is used when the user requests API testing, contract testing, or validation against OpenAPI specifications. The skill analyzes API endpoints and generates test suites covering CRUD operations, authentication flows, and security aspects. It also validates response status codes, headers, and body structure. Use this skill when the user mentions "API testing", "REST API tests", "GraphQL API tests", "contract tests", or "OpenAPI validation".