test-engineering

Resume an interrupted TDD workflow from saved state

Test-Driven Development workflow - write failing tests first, then implement, then refactor

Execute an agent team definition with optional CLI configuration overrides

Analyze code to identify testing needs, detect frameworks, and prioritize test targets

Execute existing tests and report structured results

Fully automated test generation workflow with no approval gates

Human-in-the-loop testing workflow with approval gates at key decision points

Generates a structured test plan from design documentation. Produces risk-driven scope, edge cases, test approach splits, cadence, and entry/exit criteria.

Resume an interrupted test loop workflow from saved state

Discover and inventory existing RPC registrations across the codebase

Analyzes code to identify testing needs, detect frameworks, and prioritize test targets

Example LLT analysis output for a C++ Unreal Engine LowLevelTests project using Catch2

Example analysis output for a Python project using pytest

Example E2E analysis output for a TypeScript project using Playwright

Reviews scripts and source code files to determine if logic can be moved to SKILL.md algorithms for agentic execution

Generic SDD task implementation agent for executing individual tasks from task breakdown

Writes minimal implementation code to make failing TDD tests pass (TDD GREEN phase)

Improves implementation code quality without changing behavior (TDD REFACTOR phase)

Writes failing tests from requirements and creates stubs for target modules (TDD RED phase)

Validates test results, performs root cause analysis on failures, and provides actionable recommendations

Integrate with project build systems to configure test dependencies and execution. Use when setting up testing frameworks in Maven, CMake, .NET, and Go projects, including adding test dependencies, configuring build targets, and ensuring test discovery.

Generic E2E web test authoring contracts. Defines universal error taxonomy (E1-E6), agent behavior contracts for all 5 agents when test_type=e2e, knowledge management conventions, and browser exploration interface. Framework-agnostic -- does NOT define selector rankings, wait hierarchies, fix strategies, or error regex patterns. Those belong in framework-specific reference files under skills/e2e/frameworks/.

Detect testing frameworks and application frameworks in target projects. Use when analyzing a codebase to identify which testing framework is configured (pytest, Jest, JUnit, xUnit, Google Test, Unreal Engine LLT, etc.) across Python, JavaScript, TypeScript, Java, C#, Go, C++, and Unreal Engine.

Query, reply to, and resolve GitHub PR review threads. Use when user asks to respond to PR comments, resolve review threads, check PR feedback, address reviewer concerns, or post PR summary comments. Supports batch operations and works with any GitHub repository. Requires --repo parameter.

Automatically detect and extract repeated test helper code into shared utility modules. Use when generated tests contain duplicated setup, teardown, or assertion logic that should be refactored into reusable test helpers.

Build LowLevelTest executables using UnrealBuildTool or BuildGraph.

This document defines the shared response format, data structures, validation rules, and logging instructions used by all LLT skills. Each LLT skill SKILL.md references this file for these shared conventions.

**Metadata**:

Identify relevant tests for modified source files in Unreal Engine LowLevelTests framework

Find source files tested by a test file, or find tests for a source file using evidence-based confidence scoring

Discover LowLevelTest targets in Unreal Engine projects. Parses BuildGraph XML and filesystem to enumerate test targets with metadata.

Specialized guidance for working with Epic's Online Tests framework (OSSv2 testing)

Parse Catch2 test results from XML reports and console logs

Execute LowLevelTests locally or via Gauntlet for console platforms

Specialized guidance for working with WebTests (LLTs for web runtime environments)

Orchestrate end-to-end LowLevelTest workflows by chaining discovery, build, execution, and reporting steps

Resolve the optimal Claude model (Opus, Sonnet, or Haiku) for each agent based on configuration precedence and runtime overrides. Use when launching agents to determine which model to use based on task complexity and user preferences.

Dante plugin-specific development standards. Use when contributing to the plugin, adding new skills/commands, or understanding plugin architecture. NOT for downstream users.

Detect project root directory from any path within a project, with validation to prevent writing to incorrect locations. Use when resolving the correct project root for test file placement and build system interaction.

This skill provides the write-agent with knowledge and heuristics to detect and prevent redundant test scenario generation. The skill defines equivalence classes for test inputs, classification rules for mapping values to classes, and a detection algorithm to identify when a proposed test covers the same scenario as an existing test.

Parse test framework output to extract results, failures, and coverage information. Use when processing test execution output from pytest, Jest, JUnit, xUnit, Google Test, Go test, and other frameworks to extract pass/fail counts, failure details, and stack traces.

Performs the C++ half of RPC discovery. The goal is to find all RPCs registered within C++ managers — their names, HTTP paths, categories, parameters, and which file/line they appear in. Note that the output of some files may be large, so keep that in mind when issuing tool calls.

Performs the C# half of RPC discovery. The goal is to find all C# RPC library wrapper methods. Note that the output of some files may be large, so keep that in mind when issuing tool calls.

The Discovery Cache allows commands that consume RPC discovery results (`/rpc-curate`, `/rpc-scenario`) to skip a full re-scan. The cache is keyed by timestamp. If a cache exists, consumers can use it directly. If no cache exists, a full scan is required.

The RPC Discovery Scanner is a service that discovers existing RPC implementations across the codebase using a parallel discovery architecture (TD-6). Two independent scans run concurrently: C++ discovery (grep for `RegisterHttpCallback` registrations + detailed parameter/context extraction) and C# library discovery (grep for wrapper methods in `*RpcLibrary*.cs`). Results are merged by canonical RPC name into a unified inventory with completeness tracking across all three implementation layers (hook, endpoint, library).

Generates JSON documentation for a single C++ RPC hook by reading its registration and handler implementation. Use when documenting RPC endpoints from C++ source files.

Coordinator entry point for hierarchical agent team orchestration. Manages the full workflow from team definition loading through agent spawning, lifecycle tracking, retry logic, result aggregation, and approval gates.

Structured event logging for agent team orchestration with non-blocking writes to .claude/telemetry-[timestamp].log

Provides test code templates for 22 testing frameworks across all supported languages. Use when generating test files to follow framework-specific conventions, file structure, imports, assertions, and test organization patterns for pytest, Jest, JUnit, xUnit, Google Test, Go testing, Kotlin, Playwright, Catch2 LLT, and more.

Guide automated generation of high-quality unit, integration, and E2E tests. Use when writing test code to apply language-specific patterns, mocking strategies, async test patterns, and best practices for Python, JavaScript, TypeScript, Java, C#, Go, and C++.

Detect and enforce correct test file locations per project and language conventions. Use when determining where to place generated test files based on project structure, build system configuration, and language-specific conventions.

Generates a structured, risk-driven test plan from design documentation. The output follows a standardized format used by QA teams to plan testing for features, systems, and initiatives.