
Qe Test Generation
- 33 installs
- 433 repo stars
- Updated August 4, 2026
- proffesor-for-testing/agentic-qe
qe test generation is a Claude Code skill for testing & qa.
About
qe test generation is a Claude Code skill for testing & qa. It helps solo builders move faster with AI-assisted development.
- qe test generation
- Testing & QA
- AI-coding skill
Qe Test Generation by the numbers
- 33 all-time installs (skills.sh)
- Ranked #1,333 of 2,153 Testing & QA skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill qe-test-generationAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 33 |
|---|---|
| repo stars | ★ 433 |
| Last updated | August 4, 2026 |
| Repository | proffesor-for-testing/agentic-qe ↗ |
How do I helps with testing & qa tasks.?
Helps with testing & qa tasks.
Who is it for?
Best when you're working on testing & qa and need structured help with qe test generation.
Skip if: Teams with no testing & qa needs, or anyone wanting a generic chat assistant without this specific workflow.
When should I use this skill?
When you need to helps with testing & qa tasks., or when qe test generation is a claude code skill for testing & qa.
What you get
Structured output aligned to qe test generation: qe test generation, Testing & QA.
Files
QE Test Generation
Purpose
Guide the use of v3's AI-powered test generation capabilities including pattern-based test synthesis, multi-framework support, and intelligent test case derivation from code analysis.
Activation
- When generating tests for new code
- When improving test coverage
- When migrating tests between frameworks
- When applying TDD patterns
- When generating edge case tests
Quick Start
# Generate unit tests for a file
aqe test generate --file src/services/UserService.ts --framework jest
# Generate tests with coverage target
aqe test generate --scope src/api/ --coverage 90 --type unit
# Generate integration tests
aqe test generate --file src/controllers/AuthController.ts --type integration
# Generate from patterns
aqe test generate --pattern repository --target src/repositories/Agent Workflow
// Spawn test generation agents
Task("Generate unit tests", `
Analyze src/services/PaymentService.ts and generate comprehensive Jest tests.
Include:
- Happy path tests for all public methods
- Edge cases and boundary conditions
- Error handling scenarios
- Mock external dependencies
Output to tests/unit/services/PaymentService.test.ts
`, "qe-test-generator")
// Pattern-based generation
Task("Apply test patterns", `
Scan src/repositories/ and apply repository test pattern:
- CRUD operation tests
- Query builder tests
- Transaction tests
- Connection error handling
`, "qe-pattern-matcher")Test Generation Strategies
1. Code Analysis Based
await testGenerator.analyzeAndGenerate({
source: 'src/services/OrderService.ts',
analysis: {
methods: true,
branches: true,
dependencies: true,
errorPaths: true
},
output: {
framework: 'jest',
style: 'describe-it',
assertions: 'expect'
}
});2. Pattern-Based Generation
await testGenerator.applyPattern({
pattern: 'service-layer',
targets: ['src/services/*.ts'],
customizations: {
mockStrategy: 'jest.mock',
asyncHandling: 'async-await',
errorAssertion: 'toThrow'
}
});3. Coverage-Driven Generation
await testGenerator.fillCoverageGaps({
coverageReport: 'coverage/lcov.info',
targetCoverage: 90,
prioritize: ['uncovered-branches', 'error-paths'],
maxTests: 50
});Framework Support
| Framework | Unit | Integration | E2E | Mocking |
|---|---|---|---|---|
| Jest | ✅ | ✅ | ⚠️ | jest.mock |
| Vitest | ✅ | ✅ | ⚠️ | vi.mock |
| Mocha | ✅ | ✅ | ❌ | sinon |
| Pytest | ✅ | ✅ | ❌ | pytest-mock |
| JUnit | ✅ | ✅ | ❌ | Mockito |
Test Quality Checks
quality_checks:
assertions:
minimum_per_test: 1
meaningful: true
isolation:
no_shared_state: true
proper_setup_teardown: true
naming:
descriptive: true
follows_convention: true
coverage:
branches: 80
statements: 85Skill Composition
- After generating tests → Run
/mutation-testingto verify test quality - Before generating → Use
/test-automation-strategyto choose framework and patterns - Related →
/qe-coverage-analysisto find where tests are needed most
Gotchas
- Agent truncates output on files >3000 lines — scope generation to individual modules, not entire directories
- Components that pass unit tests individually may have zero integration wiring — always generate at least one integration test per module boundary
- When generating tests for a new codebase, check which framework is installed (jest vs vitest vs mocha) — they have different mock APIs and Claude will use the wrong one
- Completion theater: agent may claim "comprehensive tests generated" but leave stubs or hardcoded values — always run the generated tests before accepting
- Fleet must be initialized before using QE agents: run
aqe healthto diagnose, oraqe initto re-initialize if you get "Fleet not initialized"
Coordination
Primary Agents: qe-test-generator, qe-pattern-matcher, qe-test-architect Coordinator: qe-test-generation-coordinator Related Skills: qe-coverage-analysis, qe-test-execution
{
"$schema": "./config-schema.json",
"_description": "QE Test Generation configuration. Auto-created on first run. Edit to customize.",
"framework": null,
"style": null,
"coverageTarget": 80,
"outputDir": "tests/",
"options": {
"generateIntegrationTests": true,
"generateEdgeCases": true,
"maxTestsPerFile": 20
},
"_setupPrompt": "If framework is null, ask the user: 'Which test framework does this project use? (jest/vitest/mocha/playwright)'. If style is null, ask: 'Do you prefer London (mock-based) or Chicago (state-based) TDD style?'"
}
skill: qe-test-generation
version: 1.0.0
description: >
Evaluation suite for AI-powered test generation.
Tests unit test generation, integration test creation, and edge case coverage.
models_to_test:
- claude-sonnet-4-6 # Primary (high accuracy expected)
- claude-haiku-4-5 # Fast model (minimum quality floor)
mcp_integration:
enabled: true
namespace: skill-validation
query_patterns: true
track_outcomes: true
store_patterns: true
target_agents:
- qe-learning-coordinator
learning:
store_success_patterns: true
pattern_ttl_days: 90
result_format:
json_output: true
include_timing: true
include_token_usage: true
setup:
required_tools:
- jq
test_cases:
- id: tc001_unit_test_generation
description: "Generate unit tests for function"
category: test_generation
priority: critical
input:
code: |
function add(a, b) {
return a + b;
}
language: "javascript"
test_framework: "jest"
expected_output:
must_contain:
- "test"
- "describe"
- "expect"
- "add"
validation:
schema_check: true
keyword_match_threshold: 0.8
- id: tc002_edge_case_detection
description: "Generate tests for edge cases"
category: edge_cases
priority: high
input:
code: |
function divide(a, b) {
return a / b;
}
language: "javascript"
expected_output:
must_contain:
- "zero"
- "edge"
- "negative"
validation:
schema_check: true
- id: tc003_integration_test_generation
description: "Generate integration tests"
category: integration
priority: high
input:
code: "API endpoint handler"
test_type: "integration"
framework: "jest"
expected_output:
must_contain:
- "integration"
- "test"
- "API"
validation:
schema_check: true
- id: tc004_test_coverage_analysis
description: "Analyze and improve test coverage"
category: coverage
priority: medium
input:
current_coverage_percent: 60
target_coverage_percent: 80
uncovered_lines: ["function error() {", "throw new Error()"]
expected_output:
must_contain:
- "coverage"
- "test"
validation:
schema_check: true
- id: tc005_test_quality_metrics
description: "Evaluate test quality metrics"
category: quality
priority: medium
input:
tests:
- "test_basic_flow"
- "test_error_handling"
- "test_edge_cases"
expected_output:
must_contain:
- "quality"
- "metric"
validation:
schema_check: true
allow_partial: true
success_criteria:
pass_rate: 0.9
critical_pass_rate: 1.0
avg_reasoning_quality: 0.75
max_execution_time_ms: 300000
metadata:
author: "qe-test-architect"
created: "2026-02-02"
coverage_target: >
Test generation with 5 test cases covering unit tests, edge cases,
integration tests, coverage analysis, and quality metrics.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://agentic-qe.dev/schemas/qe-test-generation-output.json",
"title": "AQE Test Generation Skill Output Schema",
"description": "Schema for AI-powered test generation skill output. Includes generated tests, coverage targets, and pattern matching.",
"type": "object",
"required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
"properties": {
"skillName": {
"type": "string",
"const": "qe-test-generation",
"description": "Must be 'qe-test-generation'"
},
"version": {
"type": "string",
"pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
},
"timestamp": {
"type": "string",
"format": "date-time"
},
"status": {
"type": "string",
"enum": ["success", "partial", "failed", "skipped"]
},
"trustTier": {
"type": "integer",
"const": 3
},
"output": {
"type": "object",
"required": ["summary", "generatedTests", "coverage"],
"properties": {
"summary": {
"type": "string",
"minLength": 50,
"maxLength": 2000
},
"generatedTests": {
"$ref": "#/$defs/generatedTestsReport"
},
"coverage": {
"$ref": "#/$defs/coverageTarget"
},
"patterns": {
"$ref": "#/$defs/patternAnalysis"
},
"qualityMetrics": {
"$ref": "#/$defs/testQualityMetrics"
},
"codeAnalysis": {
"$ref": "#/$defs/codeAnalysis"
},
"recommendations": {
"type": "array",
"items": {
"$ref": "#/$defs/recommendation"
},
"maxItems": 50
},
"artifacts": {
"type": "array",
"items": {
"$ref": "#/$defs/artifact"
},
"maxItems": 100
}
}
},
"metadata": {
"$ref": "#/$defs/metadata"
},
"validation": {
"$ref": "#/$defs/validationResult"
},
"learning": {
"$ref": "#/$defs/learningData"
}
},
"$defs": {
"generatedTestsReport": {
"type": "object",
"required": ["total"],
"properties": {
"total": {
"type": "integer",
"minimum": 0,
"description": "Total tests generated"
},
"byType": {
"type": "object",
"properties": {
"unit": { "type": "integer", "minimum": 0 },
"integration": { "type": "integer", "minimum": 0 },
"e2e": { "type": "integer", "minimum": 0 },
"property": { "type": "integer", "minimum": 0 }
}
},
"byCategory": {
"type": "object",
"properties": {
"happyPath": { "type": "integer", "minimum": 0 },
"edgeCases": { "type": "integer", "minimum": 0 },
"errorCases": { "type": "integer", "minimum": 0 },
"boundary": { "type": "integer", "minimum": 0 },
"negative": { "type": "integer", "minimum": 0 }
}
},
"tests": {
"type": "array",
"items": {
"$ref": "#/$defs/generatedTest"
},
"maxItems": 500
}
}
},
"generatedTest": {
"type": "object",
"required": ["id", "name", "type"],
"properties": {
"id": {
"type": "string",
"pattern": "^TEST-\\d{3,6}$"
},
"name": {
"type": "string",
"minLength": 10,
"maxLength": 300
},
"description": {
"type": "string",
"maxLength": 1000
},
"type": {
"type": "string",
"enum": ["unit", "integration", "e2e", "property", "snapshot"]
},
"category": {
"type": "string",
"enum": ["happy-path", "edge-case", "error-case", "boundary", "negative", "smoke"]
},
"sourceFile": {
"type": "string",
"description": "File being tested"
},
"testFile": {
"type": "string",
"description": "Generated test file path"
},
"code": {
"type": "string",
"maxLength": 10000,
"description": "Generated test code"
},
"framework": {
"type": "string",
"enum": ["jest", "vitest", "mocha", "pytest", "junit", "playwright", "cypress"]
},
"assertions": {
"type": "integer",
"minimum": 1,
"description": "Number of assertions"
},
"mocks": {
"type": "array",
"items": { "type": "string" },
"description": "Mocked dependencies"
},
"tags": {
"type": "array",
"items": { "type": "string" }
},
"confidence": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "Generation confidence"
},
"pattern": {
"type": "string",
"description": "Pattern used for generation"
}
}
},
"coverageTarget": {
"type": "object",
"required": ["current", "projected"],
"properties": {
"current": {
"type": "object",
"properties": {
"statement": { "type": "number", "minimum": 0, "maximum": 100 },
"branch": { "type": "number", "minimum": 0, "maximum": 100 },
"function": { "type": "number", "minimum": 0, "maximum": 100 },
"line": { "type": "number", "minimum": 0, "maximum": 100 }
}
},
"projected": {
"type": "object",
"properties": {
"statement": { "type": "number", "minimum": 0, "maximum": 100 },
"branch": { "type": "number", "minimum": 0, "maximum": 100 },
"function": { "type": "number", "minimum": 0, "maximum": 100 },
"line": { "type": "number", "minimum": 0, "maximum": 100 }
},
"description": "Projected coverage after adding generated tests"
},
"target": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Target coverage percentage"
},
"improvement": {
"type": "object",
"properties": {
"statement": { "type": "number" },
"branch": { "type": "number" },
"function": { "type": "number" },
"line": { "type": "number" }
},
"description": "Expected improvement"
},
"uncoveredPaths": {
"type": "array",
"items": {
"type": "object",
"properties": {
"file": { "type": "string" },
"lines": { "type": "array", "items": { "type": "integer" } },
"functions": { "type": "array", "items": { "type": "string" } }
}
},
"maxItems": 100,
"description": "Paths not covered by new tests"
}
}
},
"patternAnalysis": {
"type": "object",
"properties": {
"patternsApplied": {
"type": "array",
"items": {
"$ref": "#/$defs/testPattern"
}
},
"patternsAvailable": {
"type": "array",
"items": { "type": "string" }
},
"patternMatches": {
"type": "integer",
"minimum": 0
}
}
},
"testPattern": {
"type": "object",
"required": ["name", "applied"],
"properties": {
"name": {
"type": "string",
"description": "Pattern name (e.g., service-layer, repository, controller)"
},
"applied": {
"type": "integer",
"minimum": 0
},
"testsGenerated": {
"type": "integer",
"minimum": 0
},
"description": {
"type": "string"
}
}
},
"testQualityMetrics": {
"type": "object",
"properties": {
"assertionsPerTest": {
"type": "number",
"minimum": 0
},
"isolationScore": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Test isolation score"
},
"namingQuality": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Descriptive naming score"
},
"maintainabilityScore": {
"type": "number",
"minimum": 0,
"maximum": 100
},
"issues": {
"type": "array",
"items": {
"type": "object",
"properties": {
"type": { "type": "string" },
"test": { "type": "string" },
"message": { "type": "string" }
}
}
}
}
},
"codeAnalysis": {
"type": "object",
"properties": {
"filesAnalyzed": {
"type": "integer",
"minimum": 0
},
"functionsAnalyzed": {
"type": "integer",
"minimum": 0
},
"classesAnalyzed": {
"type": "integer",
"minimum": 0
},
"complexity": {
"type": "object",
"properties": {
"average": { "type": "number" },
"max": { "type": "number" }
}
},
"dependencies": {
"type": "array",
"items": { "type": "string" }
},
"mockCandidates": {
"type": "array",
"items": { "type": "string" },
"description": "Suggested items to mock"
}
}
},
"recommendation": {
"type": "object",
"required": ["id", "title", "priority"],
"properties": {
"id": {
"type": "string",
"pattern": "^REC-\\d{3,6}$"
},
"title": {
"type": "string",
"minLength": 10,
"maxLength": 200
},
"description": {
"type": "string",
"maxLength": 2000
},
"priority": {
"type": "string",
"enum": ["critical", "high", "medium", "low"]
},
"type": {
"type": "string",
"enum": ["coverage-gap", "missing-edge-case", "refactoring", "pattern-suggestion"]
},
"targetFiles": {
"type": "array",
"items": { "type": "string" }
}
}
},
"artifact": {
"type": "object",
"required": ["type", "path"],
"properties": {
"type": {
"type": "string",
"enum": ["test-file", "report", "coverage", "data"]
},
"path": { "type": "string", "maxLength": 500 },
"format": {
"type": "string",
"enum": ["ts", "js", "py", "java", "json", "html", "md"]
},
"description": { "type": "string" }
}
},
"metadata": {
"type": "object",
"properties": {
"executionTimeMs": { "type": "integer", "minimum": 0 },
"framework": {
"type": "string",
"enum": ["jest", "vitest", "mocha", "pytest", "junit", "playwright", "cypress"]
},
"agentId": { "type": "string", "pattern": "^qe-[a-z][a-z0-9-]*$" },
"modelUsed": { "type": "string" },
"sourceScope": { "type": "string" }
}
},
"validationResult": {
"type": "object",
"properties": {
"schemaValid": { "type": "boolean" },
"contentValid": { "type": "boolean" },
"confidence": { "type": "number", "minimum": 0, "maximum": 1 },
"warnings": { "type": "array", "items": { "type": "string" } },
"errors": { "type": "array", "items": { "type": "string" } }
}
},
"learningData": {
"type": "object",
"properties": {
"patternsDetected": { "type": "array", "items": { "type": "string" } },
"reward": { "type": "number", "minimum": 0, "maximum": 1 },
"newPatterns": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": { "type": "string" },
"codeSignature": { "type": "string" },
"testTemplate": { "type": "string" }
}
}
}
}
}
}
}
{
"skillName": "qe-test-generation",
"skillVersion": "1.0.0",
"requiredTools": [
"jq"
],
"optionalTools": [],
"schemaPath": "schemas/output.json",
"requiredFields": [
"skillName",
"status",
"output"
],
"requiredNonEmptyFields": [],
"mustContainTerms": [],
"mustNotContainTerms": [],
"enumValidations": {
".status": [
"success",
"partial",
"failed",
"skipped"
]
}
}
Jest Unit Test Scaffold
Class Under Test Pattern
import { {{ClassName}} } from '../src/{{path}}';
describe('{{ClassName}}', () => {
let sut: {{ClassName}};
beforeEach(() => {
sut = new {{ClassName}}(/* dependencies */);
});
describe('{{methodName}}', () => {
it('should return expected result for valid input', () => {
// Arrange
const input = /* valid input */;
// Act
const result = sut.{{methodName}}(input);
// Assert
expect(result).toBe(/* expected */);
});
it('should throw for invalid input', () => {
expect(() => sut.{{methodName}}(null)).toThrow();
});
it('should handle edge case: empty input', () => {
const result = sut.{{methodName}}(/* empty */);
expect(result).toBe(/* expected for empty */);
});
it('should handle edge case: boundary value', () => {
const result = sut.{{methodName}}(/* boundary */);
expect(result).toBe(/* expected at boundary */);
});
});
});Integration Test Pattern
describe('{{Feature}} Integration', () => {
beforeAll(async () => {
await setupTestDatabase();
});
afterAll(async () => {
await teardownTestDatabase();
});
it('should complete the full workflow', async () => {
// Step 1: Create
const created = await service.create(validPayload);
expect(created.id).toBeDefined();
// Step 2: Read
const fetched = await service.getById(created.id);
expect(fetched).toMatchObject(validPayload);
// Step 3: Update
const updated = await service.update(created.id, changes);
expect(updated.field).toBe(changes.field);
// Step 4: Delete
await service.delete(created.id);
await expect(service.getById(created.id)).rejects.toThrow('Not found');
});
});Related skills
FAQ
What does qe test generation do?
qe test generation is a Claude Code skill for testing & qa.
When should I use qe test generation?
When you need to helps with testing & qa tasks., or when qe test generation is a claude code skill for testing & qa.
What are the main capabilities?
qe test generation; Testing & QA; AI-coding skill.