Results for “characterization-testing”

Guides adding characterization tests before modifying or refactoring untested legacy code, using the RGR workflow and strangler fig pattern to reduce risk.

Analyzes test suites across multiple languages and tags each test with standardized traits (positive, negative, critical-path, etc.) for better test categorization and coverage visibility.

Catalysis Based Testing Skill

Design, prioritize, and evaluate product experiments with clear hypotheses and defensible decisions, including A/B testing, sample size estimation, and statistical interpretation.

Stress-test a feature idea for an existing product by surfacing risky assumptions across Value, Usability, Viability, and Feasibility using multi-perspective devil's advocate thinking.

---

Design statistically valid A/B tests with hypothesis frameworks, sample size calculations, and analysis checklists.

Provides guidance for property-based testing across multiple languages and smart contracts, helping detect patterns where PBT offers stronger coverage than example-based tests.

Triage mutation testing results by combining survived mutants, unnecessary test statements, and code graph analysis to identify false positives, missing test coverage, and fuzzing targets.

Audits colour decisions on a screen for contrast ratios, palette coherence, semantic meaning, and accessibility, flagging deviations and recommending specific corrections.

The science of learning through controlled experimentation. A/B testing isn't about picking winners—it's about building a culture of validated learning and reducing the cost of being wrong. This skill covers experiment design, statistical rigor, feature flagging, analysis, and building experimentation into product development. The best experimenters know that every test, positive or negative, teaches something valuable. Use when "a/b test, experiment, hypothesis, statistical significance, sample size, feature flag, variant, control, treatment, p-value, conversion rate, test winner, split test, experimentation, testing, statistics, feature-flags, hypothesis, growth, optimization, learning, validation" mentioned.

Scores competitors across nine weighted dimensions with explicit 1–5 rubrics and a tension plot, producing comparable profile cards for competitive analysis.

Write reliable Kotlin tests using Kotest, MockK, coroutine testing, property-based testing, and Kover coverage, following a TDD workflow.

Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.

Generate tests, design test strategies, and ensure code quality through testing. Use when writing tests, improving test coverage, designing test infrastructure, or evaluating test quality.

Use `analysis-agent` to map acceptance to validation, `task-agent` to add or run bounded tests, and `review-agent` to assess proof coverage. Skip work with no material change or already-fresh complete validation.

Safely change and test untested codebases using techniques from Feathers' 'Working Effectively with Legacy Code': seams, characterization tests, sprout/wrap, and dependency-breaking.

`task-agent`/`review-agent`: use when CPU, memory, I/O, database, network, rendering, or cost needs measured bottleneck evidence; skip without a profiling need.

Design and evaluate paid-ad experiments with hypotheses, randomization, sample-size calculations, guardrails, and decision rules for A/B and split tests.

Cardinality and model family jointly determine the encoding.

`analysis-agent`/`task-agent`/`review-agent`: use when behavior needs deterministic seams for time, randomness, UUIDs, collaborators, or external I/O; skip when seams are adequate.

Write, fix, and run C++ tests using GoogleTest/GoogleMock with CMake/CTest, including TDD workflows, coverage, and sanitizers.

Strengthen interfaces against edge cases, errors, internationalization issues, and real-world usage scenarios that break idealized designs.

Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.

Provides a workflow for writing, updating, and fixing C++ tests with GoogleTest/GoogleMock, configuring CMake/CTest, diagnosing failures, and adding coverage or sanitizers.

`analysis-agent`/`task-agent`/`review-agent`: use when logic, rules, invariants, branches, edges, or failure paths need isolated tests; skip without a unit-test decision.

Skill Tester

Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.

Guides statistical hypothesis testing with assumption checks, effect sizes, power analysis, Bayesian alternatives, and APA-formatted reporting for research data.

Assess the test suite of a codebase — where tests are missing, where they exist but are weak, and which gaps actually matter. Use this skill whenever the user asks about test coverage, test quality, "are there enough tests", "where should we add tests", testing gaps, test debt, untested code paths, flaky tests, or generally wants to know whether a codebase is well-tested. Trigger even on casual phrasings ("is this tested?", "what's the test situation?", "audit our tests"). This skill does NOT write tests — it only assesses what exists and identifies what's missing. For test generation, this is the wrong skill.

Stress-test ideas, plans, and decisions using structured critical reasoning across five modes: Socratic questioning, dialectic, pre-mortem, red teaming, and evidence audit.

Run Mom Test–style customer-discovery interviews to validate or kill an unbuilt idea — generate a non-leading interview guide, conduct or coach the conversations, and synthesize signal vs compliments. Load when the user asks to do customer discovery, run problem interviews, validate an idea with users, run a Mom Test, design an interview guide, or says "talk to customers", "validate the problem", "interview users", "Mom Test this", "did real users want it", "synthesize my interviews", "I just talked to N people". Sub-skill of `venture-exploration`. Hard-bans "would you use this?", solution-pitching, friend/family-only ICP, and treating compliments as validation. Calls `secure-*` before synthesizing any pasted external transcripts.

Plan, design, and analyze A/B tests and growth experiments, from hypothesis to statistically sound results.

Test React components with RTL and Jest/Vitest. Use when writing React component tests with React Testing Library, Jest, or Vitest.

Nocaps: Novel Object Captioning at Scale