Testing
Writing, fixing and strengthening automated tests.
Download all 101
Start here 2
The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.
- Write unit tests
Writes unit tests that pin a unit's behaviour, covering boundaries, errors and edge inputs in the project's own test style, and proves each test can fail. Use for new or untested code.
- Write a test plan
Writes a risk-based test plan for a feature or release covering scope, risks, test levels, environments, data, manual checks automation misses and exit criteria. Use before testing a release.
Specific 90
One situation, audience, tool or format inside the category. Example: Plan a road trip with children.
- Review test quality
Reviews a test suite or diff for weak assertions, over-mocking, hidden coupling, sleeps, nondeterminism and tests that cannot fail, with a concrete rewrite for each problem. Use when reviewing tests.
- Test-writing rules
Standing rules for tests an assistant writes, covering behaviour over implementation, no sleeps, deterministic data, mocks only at boundaries and one reason to fail per test.
- Test engineer
Designs and writes tests that catch real regressions, chooses the cheapest test level that proves a behaviour, and refuses flaky or assertion-free tests. Use as a testing persona or subagent.
- Write property-based tests
Finds the invariants a function must keep and writes property-based tests with generators that shrink well. Use when example-based tests miss edge cases in parsers, encoders or pure logic.
- Fix a flaky test
Finds why a test passes and fails intermittently and fixes the cause instead of adding retries. Use when a test fails only sometimes, locally or in CI.
- Add characterization tests to legacy code
Pins down what untested legacy code does today with characterization and golden-master tests, bugs included, so it can be changed safely. Use before refactoring or modifying code with no tests.
- Write a resilient end-to-end test
Writes an end-to-end browser test for a user flow with role-based locators, auto-waiting assertions and isolated test data, never fixed sleeps. Use when adding UI coverage for a critical path.
- Write manual test cases
Writes manual test cases a non-developer can run, with preconditions, numbered steps, test data, expected results and priority, grouped into smoke and full passes. Use for UAT or before automation.
- Exploratory tester
Acts as a curious, sceptical exploratory tester who hunts bugs automation misses with tours, heuristics and oracles, and writes bug reports developers can reproduce. Use as a testing partner.
- Find test pollution
Finds tests that pass alone but fail when run with others, by bisecting test order to the polluting test and fixing the leaked state, environment or database rows.
- Test time-dependent code
Makes code that depends on the current time, timers, time zones or daylight saving testable with an injected clock or fake timers, then writes tests for expiry, scheduling and calendar edge dates.
- Write Gherkin scenarios
Turns acceptance criteria into declarative Given/When/Then scenarios with one behaviour each, scenario outlines for data variants and business language that survives UI changes. Use in BDD teams.
- Write Postman or Bruno collection tests
Writes an API test collection for Postman or Bruno with environments, chained requests, assertion scripts and data cleanup, and runs it from the command line in CI.
- Find and fill the riskiest test gaps
Finds untested behaviour that matters most, ranked by risk rather than coverage percentage, and writes tests for the top gaps. Use when a module feels under-tested or before a risky change.
- Fix a red test suite after an upgrade or merge
Takes a red test suite back to green in gated steps, clustering failures, proving each root cause and fixing code or outdated tests with evidence. Use after an upgrade or merge breaks many tests.
- Raise meaningful test coverage across a codebase
Raises test coverage where it reduces risk, measuring first, writing behaviour tests for risky untested code and checking them with sampled mutation testing. Use for a coverage push that must count.
- Automate manual test cases
Chooses which manual test cases are worth automating and converts them into API, integration or end-to-end tests at the lowest level that still catches the defect.
- Generate pairwise test combinations
Generates a pairwise (all-pairs) combination set for many configuration options or inputs, honouring constraints on invalid combinations, and proves every pair is covered.
- Implement Cucumber step definitions
Implements Cucumber, SpecFlow/Reqnroll or Behave step definitions for Gherkin scenarios with reusable parameterised steps, per-scenario shared context and no step sprawl.
- Plan user acceptance testing
Plans user acceptance testing with business-readable scenarios, chosen testers, test data, a defect process and sign-off criteria. Use before business users accept a system or release.
- Test asynchronous code reliably
Writes tests for promises, callbacks, event emitters, streams and eventually consistent results without sleeps, unawaited assertions or false passes.
- Test transactional email flows
Tests transactional emails such as sign-up confirmation and password reset by capturing messages in a local inbox, asserting content and links, and following the links in end-to-end tests.
- Test game mechanics deterministically
Makes game logic testable with a fixed timestep, seeded randomness and input replays, then writes tests for combat, physics and progression rules. Use when only manual playtests catch regressions.
- Test a payment integration
Tests a payment integration with the provider's test mode, test cards, signed simulated webhooks and subscription time travel, covering declines, 3-D Secure, refunds and duplicate events.
- Write exploratory test charters
Writes session-based exploratory testing charters for a feature with time boxes, heuristics, a session sheet and a debrief agenda, aimed at risks automation misses. Use before a release.
- Write post-deploy smoke tests
Writes a fast post-deploy smoke test suite for critical paths that gates promotion or triggers rollback, safe to run against production. Use when deploys lack a quick health check.
- Write Storybook interaction tests
Writes Storybook stories for a component's real states with play functions that interact and assert, mocks data at the network boundary, and runs them as tests in CI.
- Write test data factories
Writes test data builders or factories that produce valid objects by default and take short, readable overrides. Use when tests are full of copy-pasted fixtures that break on every model change.
- Write visual regression tests
Writes visual regression tests for UI components with deterministic snapshots, tight diff thresholds, a state matrix and CI setup. Use when CSS changes keep breaking screens nobody rechecked.
- Test FastAPI endpoints
Tests FastAPI endpoints with TestClient or httpx AsyncClient, dependency_overrides, per-test database rollback, auth fixtures and lifespan handling, covering status codes and side effects.
- Test Terraform modules
Tests a Terraform or OpenTofu module with the native test framework, plan-only assertions with mocked providers, variable validation and optional apply tests in a sandbox, and runs them in CI.
- Write Django tests
Writes Django tests for models, views, forms and permissions with the test client or pytest-django, factories, assertNumQueries, transactional isolation and on_commit handling.
- Write pytest tests
Writes pytest tests for a Python module with fixtures, parametrize, monkeypatch, tmp_path, pytest.raises and readable failures, following the project's existing conftest and plugins.
- Diagnose a failing E2E test
Diagnoses a consistently failing end-to-end test from its trace, screenshots, video and network log, decides whether the app or the test is wrong, and fixes the right one.
- Set up testing in a project
Sets up a test framework in a project that has none or a broken one - config, folder layout, a first real test, coverage, watch mode and a CI job - following the stack's conventions.
- Speed up a slow test suite
Cuts test suite runtime from timing reports and setup code by fixing slow fixtures, sleeps, database resets and isolation-safe parallelism. Use when the tests themselves, not the CI config, are slow.
- Test background jobs and queue consumers
Tests background jobs and message consumers for idempotency, retries, redelivery, poison messages, ordering and dead-letter handling, at unit and integration level.
- Test code that uses randomness
Tests code that uses randomness - shuffles, sampling, ids, jitter, A/B assignment - with injected or seeded sources, exact checks where possible and sound statistical checks where not.
- Test failure and error paths
Tests how code handles dependency failures - timeouts, errors, malformed and partial responses, retries and fallbacks - by injecting faults at the boundary. Use when only happy paths are tested.
- Test file uploads and downloads
Writes API and end-to-end tests for file upload and download features, asserting stored content, content types, size and type limits, filenames, streaming and error responses.
- Test WebSocket and real-time features
Tests WebSocket, Server-Sent Events or socket-based real-time features for connection auth, message delivery and ordering, reconnection, backpressure and multi-client behaviour.
- Write integration tests with real dependencies
Writes integration tests that run against real dependencies such as databases and queues in containers, with fixtures, isolation between tests and cleanup. Use when mocks hide bugs at the boundary.
- Write a mobile release test checklist
Writes a pre-release test checklist for an iOS or Android app covering upgrades, permissions, interruptions, offline use, device variety and store requirements.
- Write a test summary report
Writes a test summary report for a release from test results and defect data - what was tested, results, open defects, residual risk and a go or no-go recommendation.
- Add a regression test for a bug
Writes the smallest test that fails on the buggy code and passes with the fix, and proves both by running it. Use after fixing a bug, or before fixing one, so it cannot return.
- Test firmware off target
Sets up host-based unit tests for firmware by separating logic from the HAL, faking registers and peripherals, and running in CI. Use when firmware has no automated tests.
- Test custom React hooks
Tests custom React hooks with renderHook and act, wrapping the providers they need and covering async updates, re-renders with new props, cleanup on unmount and race conditions.
- Test React Native components
Tests React Native components and screens with React Native Testing Library and Jest, mocking native modules and navigation, and asserting what the user sees with async queries.
- Unit test data transformations
Writes small-fixture unit tests for SQL, dbt, pandas or Spark transformations with hand-built rows for nulls, duplicates, late records and boundaries that run in seconds in CI.
- Write UI component tests
Writes tests for a React, Vue or Svelte component that render it, interact like a user through accessible queries, mock the network at the boundary and assert what the user sees, not internals.
Showing 50 of 90. See them all in search
Advanced 9
Expert or deep work that assumes the user can judge expert output. Example: Plan croissant lamination.
- Write consumer-driven contract tests
Writes consumer-driven contract tests between two services and the CI gate that runs them, so a breaking API change fails before deploy. Use when services that call each other ship independently.
- Test concurrent code
Writes tests for concurrent code - shared state, locks, queues, worker pools, database races - using controlled interleavings, stress loops and race detectors, so races fail tests reliably.
- Write a fuzz harness
Writes a coverage-guided fuzz harness for a parser or decoder with a seed corpus, dictionary, sanitizers, a CI time budget and crash triage. Use for code that reads untrusted input.
- Test database migrations
Writes executable tests for schema and data migrations that run them up and down against realistic data, checking data is preserved and the running app version still works.
- Test numerical and scientific code
Tests numerical or scientific code with sound floating-point tolerances, trusted reference values, mathematical invariants and ill-conditioned edge cases instead of exact equality.
- Build a test dataset from production
Plans and scripts a safe test dataset derived from production - subsetting with referential integrity, masking of personal and secret data, and a repeatable refresh.
- Run mutation testing on a module
Sets up mutation testing for one module, triages the surviving mutants and writes tests that kill the ones that matter. Use when coverage looks high but you doubt the tests would catch a real bug.
- Write tests for machine learning code
Writes automated tests for ML training and inference code, covering shapes and dtypes, determinism, training sanity checks such as overfitting one batch, and behavioural invariance tests.
- Write a test strategy for a codebase or team
Writes a test strategy for a codebase or team covering test levels, what each level owns, tooling, environments, CI gates and ownership. Use when tests grew without a plan.
Not: reviewing a change (code-review); load testing (performance).