Skip to main content
skill CX Codex

antithesis-feature-workload — Claude Code skill

antithesis-feature-workload — a Claude Code skill that designs and implements a feature-scoped self-driving workload running locally and in Antithesis without Test Composer.

Apache-2.0 156 installs ★ 313 updated 2026-10-22

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add antithesishq/antithesis-skills --skill antithesis-feature-workload -a claude-code
Open on GitHub

What antithesis-feature-workload does

This skill guides the agent through inspecting a specific feature inside the system under test (SUT). It discovers concrete properties, reachable edge cases, and failure modes, then structures a self-driving workload to trigger those behaviors.

The resulting workload operates in dual mode: when ANTITHESIS_OUTPUT_DIR is set, it executes Antithesis SDK assertions such as Sometimes reach claims, falling back to local assertion checks otherwise. It accommodates both completed features and in-development code through failing TDD-style stubs that pass once implementation lands.

Local execution requires Docker Compose v2 alongside Docker or Podman. Submitting runs into Antithesis requires the snouty CLI version 0.8.0 or newer and the Antithesis plugin.

What it helps with

  • design a focused workload for a specific feature
  • define invariant assertions and reach claims using Antithesis SDK
  • generate a dual-mode test script for local container runs and Antithesis
  • build TDD assertion stubs for features currently in development

Example prompts for the agent

  • Design an Antithesis workload for our payment retry feature
  • Define reach claims and invariant checks for the auth module
  • Build a dual-mode self-driving workload runnable via Docker Compose

How to install antithesis-feature-workload

1Skills CLI (Vercel)

npx skills add antithesishq/antithesis-skills --skill antithesis-feature-workload -a claude-code

2Manually: put the files in place

~/.claude/skills/antithesis-feature-workload/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/antithesis-feature-workload/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about antithesis-feature-workload

How to install antithesis-feature-workload in Claude Code?

Run npx skills add antithesishq/antithesis-skills --skill antithesis-feature-workload -a claude-code in your terminal.

What does antithesis-feature-workload do?

It guides feature analysis, formulates testable invariants, and constructs a self-driving test program that runs identically in local containers and Antithesis.

What is required to run antithesis-feature-workload?

Access to the SUT source code, Docker Compose v2 with Docker or Podman for local checks, plus snouty CLI 0.8.0+ and the Antithesis plugin for remote runs.

Source text

SKILL.md · Apache-2.0
---
name: antithesis-feature-workload
description: >-
  Design and build an Antithesis workload for a specific feature: analyze the
  feature, discover its testable properties, build a self-driving workload
  that runs locally and in Antithesis, and iterate until the feature's
  behaviors are exercised and its invariants are checked.
metadata:
  version: "2026-11-12 6ba10e2"
  model_guidance:
    - model: all
      level: required
      instructions: >
        This skill teaches you how to build an Antithesis workload scoped to
        a specific feature. Start from a feature — done or in development —
        understand what it does and what could go wrong, discover testable
        properties, and build a self-driving workload that exercises the
        feature's behaviors and checks its invariants. The workload does NOT
        use Test Composer — it is a self-driving program that runs identically
        locally and in Antithesis.
---

# Build a feature workload for Antithesis

**Skill version:** `2026-11-12 6ba10e2`

## Purpose and Goal

Start from a specific feature and produce a workload that tests it.
Success means:

- The feature is understood well enough to identify its testable properties
- Properties are concrete and specific — invariants, reachable behaviors,
  failure modes — not vague goals
- A self-driving workload exists that exercises the feature's behaviors
- Reach claims fire, proving the workload reaches the feature's important
  states
- Feature invariants are checked by assertions that use the correct SDK types
- Optionally: the workload has run in Antithesis and findings have been
  verified

This skill is a parallel entry point into the Antithesis workflow. Where the
standard pipeline goes research → setup → workload (broad coverage), this
skill goes feature analysis → targeted workload → iterate (feature focus).

## Entry Points

This skill handles two starting points:

- **Feature is done**: Source code is available. Full analysis, full workload,
  all assertions expected to pass.
- **Feature is in development**: Some code may exist, or just a spec or idea.
  The workload includes TDD-style stubs — assertions that fail until the
  feature catches up. As code lands, assertions go green. The "Update workload
  for feature changes" workflow handles evolution.

Both entry points go through the same workflow. What varies is how many
assertions pass on the first run.

## Prerequisites

- A feature to test — source code, a spec, a description, or a combination
- Access to the SUT source code
- Docker Compose v2 and a container engine (Docker or Podman) for local runs
- `snouty` CLI 0.8.0 or newer installed when moving to Antithesis runs (not
  needed for local-only work)
- The [antithesis plugin](https://github.com/antithesishq/antithesis-plugin)
  installed when moving to Antithesis runs, for `/antithesis launch`,
  `/antithesis triage`, and `/antithesis debug`

## Relationship to Other Skills

- **antithesis-research**: Feature-workload performs *feature-scoped* analysis
  — the same codebase exploration techniques narrowed to "what could go wrong
  with this feature" rather than "what properties does this entire system
  have." If full research artifacts already exist in the scratchbook, use them
  as context but don't require them.
- **`/antithesis workload`** (antithesis plugin): Builds the system-wide
  hegel-driven workload. Feature-workload builds a feature-scoped
  self-driving workload instead. Assertion patterns, value menus,
  fault-tolerant design, and reach claims apply to both — this skill carries
  its own reference material adapted for feature-scoped work. Feature-workload
  does not assume an Antithesis harness is or isn't set up; when the user wants
  to move to Antithesis and the harness (images, compose file, setup-complete
  signal) is missing, delegate to `/antithesis workload`.
- **`/antithesis launch`**: Use to submit Antithesis runs. Do not run
  `snouty launch` directly.
- **`/antithesis triage`**: Use after each Antithesis run with a focused lens:
  "are the feature's properties being exercised? Any failures?" rather than a
  broad property portfolio review.
- **`/antithesis debug`**: Use when triage shows a property failure that needs
  deeper investigation — inspect container state at the failure moment,
  time-travel to understand the sequence.

## Definitions

- **SUT:** System under test.
- **Feature property:** A concrete, testable claim about what the feature
  should do, what invariants it should maintain, or what behaviors should be
  reachable.
- **Reach claim:** A `Sometimes` assertion that verifies the workload actually
  exercises a feature behavior. Unfired reach claims mean the workload isn't
  reaching the right states.
- **Self-driving workload:** A single program that drives the SUT, checks
  invariants, and runs without external orchestration. No Test Composer.
- **Dual-mode:** The workload uses SDK assertions when `ANTITHESIS_OUTPUT_DIR`
  is set (Antithesis) and equivalent local checks when it is not (local).

## Documentation Grounding

Use `snouty docs` to access Antithesis docs.

- SDK reference: `https://antithesis.com/docs/reference/sdk.md`
- Properties and assertions: `https://antithesis.com/docs/concepts/properties_assertions/assertions.md`
- Fault injection: `https://antithesis.com/docs/product/fault_injection.md`
- Docker Compose setup: `https://antithesis.com/docs/getting_started/setup_guide/docker_compose.md`

## Reference Files

| Reference                             | When to read                                          |
| ------------------------------------- | ----------------------------------------------------- |
| `references/feature-analysis.md`      | First — system orientation, understanding the feature, discovering properties |
| `references/self-driving-workload.md` | Building the workload                                 |
| `references/assertions.md`            | Writing assertions for feature properties and reach claims |
| `references/interesting-values.md`    | Choosing values that exercise the feature's boundaries |
| `references/faults.md`               | Assessing whether fault injection matters for this feature |
| `references/iteration.md`            | When reach claims aren't firing or properties aren't exercised |
| `references/verification.md`         | Verifying a finding is real                            |

## Recommended Workflows

### Design and build a feature workload

1. Read `references/feature-analysis.md`
2. Orient to the system: if existing research artifacts exist in
   `antithesis/scratchbook/`, read them; otherwise build a lightweight
   orientation scoped to the feature's neighborhood — architecture, data flow,
   concurrency model
3. Understand the feature — from code, spec, conversation, or combination.
   For features in development, identify what's built vs. planned
4. Discover feature properties — invariants, reachable behaviors, failure
   modes. For features in development, properties for unbuilt parts become
   TDD-style stubs
5. Read `references/faults.md` to assess which fault types matter for this
   feature
6. Record findings in
   `antithesis/feature-workloads/<feature-slug>/analysis.md`
7. Read `references/self-driving-workload.md`
8. Read `references/assertions.md`
9. Read `references/interesting-values.md`
10. Build value menus from boundary values and configured-limit families on
    the feature's code paths
11. Design and build the workload: self-driving program with dual-mode
    assertions, fault tolerance, operation tracking, and reach claims for the
    feature's key behaviors
12. Build docker-compose for local runs (or use existing setup)
13. Run locally. Read `references/iteration.md` when reach claims aren't
    firing or properties aren't being exercised. Iterate: check reach claims
    first, then adjust workload, assertions, SUT config, or properties as the
    evidence directs
    - Reach claims not firing → adjust workload or revisit feature
      understanding
    - Properties not being exercised → adjust operations, values, or
      assertions
    - Feature understanding seems wrong → loop back to step 3
14. If moving to Antithesis:
    a. Check existing setup; use `/antithesis workload` if infrastructure is needed
    b. Use `/antithesis launch` for runs
    c. Watch the run (`references/iteration.md`, "Watch the run"), or use
       `/antithesis triage` for analysis (framed: "are the feature's
       properties being exercised? Any failures?")
    d. Based on triage results: if a property failed, go to step 15; if reach
       claims aren't firing, go to "Iterate after a run"; if the mechanism is
       unclear, use `/antithesis debug` for deeper inspection
15. When a property fails, read `references/verification.md`. Classify the
    finding. Any real bug found while testing a feature is valuable.
16. Document findings in
    `antithesis/feature-workloads/<feature-slug>/analysis.md`

### Iterate after a run

1. Read `references/iteration.md`
2. Read `references/assertions.md` if assertions need to change
3. Check reach claims — are feature behaviors being reached?
4. Choose iteration moves based on what you observe: workload adjustments,
   assertion adjustments, SUT configuration changes, or property revision
5. Update `antithesis/feature-workloads/<feature-slug>/analysis.md` with what
   changed, what was observed, and what to try next

### Update workload for feature changes

For when the feature evolves and the workload needs to keep up:

1. Re-read the feature (what changed in the code or spec)
2. Check which properties still hold, which are new, which are obsolete
3. Update workload, assertions, and reach claims — TDD-style stubs for new
   unbuilt parts, remove stubs for parts that are now built and passing
4. Re-validate locally — check reach claims, iterate as in the main
   workflow's step 13 if results show gaps

## General Guidance

- **One feature at a time.** Don't try to build workloads for multiple
  features simultaneously. Each feature gets its own analysis, workload, and
  iteration cycle.
- **Properties drive the workload.** Every operation, assertion, and value
  choice should connect to a discovered feature property. If work doesn't
  relate to a property, either discover a new property or stop.
- **Reach claims are the compass.** Unfired reach claims tell you the workload
  isn't exercising the feature's key behaviors. Check them first on every
  iteration — before adjusting anything else, make sure the workload is
  reaching the right states.
- **Local is the default starting point.** Start locally unless the feature's
  properties explicitly require Antithesis capabilities (fault injection,
  scheduling control). Local iteration is faster and gives tighter feedback
  loops.
- **Verify before declaring victory.** A property failure is a candidate, not
  a confirmed bug. Read the counterexample. Understand the sequence. Confirm
  the mechanism. Harness bugs, assertion bugs, and workload bugs all produce
  property failures too.
- **Record everything.** The feature-workloads directory is the trail from
  "we have a feature" to "we have a working workload." Future readers need to
  understand what properties were discovered, what was tested, and what was
  found.
- **Design workloads to be fault-tolerant.** Under Antithesis fault injection,
  transient errors are expected. The workload must make progress through
  failures — retry with backoff, reconnect on disconnect, and track what was
  attempted vs what was acknowledged.
- **Keep Antithesis-only code out of production paths.** If you must touch
  shared code for assertions, make the change surgical. SDK assertions no-op
  outside Antithesis, so the production cost is negligible.
- **Write workload code in the project's language** so it can reuse the
  project's clients, helpers, and libraries.
- **The workload grows with the feature.** For in-development features, build
  the full workload with TDD-style stubs for unbuilt parts. Assertions go
  green as code lands. Don't wait for completion to start testing.

## Output

- `antithesis/feature-workloads/<feature-slug>/analysis.md` — feature
  properties, codebase findings, fault assessment, iteration history
- Workload code (self-driving program with dual-mode assertions)
- `docker-compose.yml` for local runs (unless existing setup suffices)
- Assertions targeting feature invariants plus reach claims for feature
  behaviors

## Self-Review

Before declaring this skill complete, review your work against the criteria
below. If your agent supports sub-agents, create a fresh-context reviewer.

Review criteria:

- System orientation was performed — enough understanding of the architecture,
  data flow, and concurrency model to navigate the feature's neighborhood (or
  existing research artifacts were used)
- Feature properties are documented in `analysis.md` and connect to specific
  code paths with evidence from the codebase (or to planned behavior for
  in-development features)
- Each property is concrete and testable — not a vague goal like "test the
  feature" but a specific invariant, reachable behavior, or failure mode
- The workload exercises the feature's key behaviors (verified by reach claims
  that actually fire — or, for in-development features, reach claims for built
  parts fire while stubs for unbuilt parts are clearly marked)
- Assertions use the correct SDK type for their semantics (`Always` /
  `AlwaysOrUnreachable` for invariants, `Sometimes` for reach claims,
  `Reachable` for path reachability) — see `references/assertions.md`
- `Sometimes(true, ...)` assertions should be rewritten as `Reachable(...)`
- The workload is a self-driving program with a single entrypoint, not Test
  Composer commands
- The workload is fault-tolerant — retries transient errors, makes progress
  through failures, doesn't bail on the first error
- The workload tracks attempted vs acknowledged operations so assertions can
  check bounds, not exact values
- The workload is dual-mode — SDK assertions when `ANTITHESIS_OUTPUT_DIR` is
  set, local checks otherwise
- Reach claims assert the precondition, not the violation — they fire when the
  system is correct
- No reach claim is the negation of an `Always` or `AlwaysOrUnreachable` at
  the same site
- Value choices use boundary values and configured-limit families from the
  feature's code paths, not arbitrary ranges — see
  `references/interesting-values.md`
- Assertion property names are inline constant string literals, unique across
  the project — never constructed at runtime
- Randomness in the workload goes through the SDK's random module for
  deterministic replay (standard library random for local mode)
- Randomness shape varies across runs (swarm testing) — probabilities and
  action weights are drawn at the start of each run, not hardcoded
- Workload-only instrumentation was not used where surgical SUT-side
  assertions would provide materially better search guidance for rare,
  dangerous, or timing-sensitive internal states
- Assertions are in workload code or surgical SUT locations — not scattered
  across production paths
- If moving to Antithesis: `/antithesis workload` was used for
  infrastructure, not ad-hoc setup
- If fault types are relevant to the feature's properties: those faults are
  confirmed as enabled for the tenant — see `references/faults.md`
- The feature-workloads directory records what was analyzed, what properties
  were discovered, what was tested, and what was found at each iteration

© antithesishq · Apache-2.0 · antithesishq/antithesis-skills

Similar skills

All skills for Testing and QA →

From the same set13

The whole set →
antithesis-setup antithesis-setup — a skill for Claude Code, Codex, Cursor, GitHub Copilot and Gemini CLI that scaffolds a docker-compose harness for the Antithesis testing platform. CX Codex +1 624installs antithesis-debug antithesis-debug executes bash scripts inside an Antithesis run at a pinned virtual moment using snouty runs exec directly from the terminal. CX Codex +1 618installs antithesis-launch The antithesis-launch skill finds an Antithesis setup, builds its Compose images, validates the config, then submits a run. Use it when you want to launch a test from a repository. CX Codex +1 554installs antithesis-skills-feedback The antithesis-skills-feedback skill prepares a GitHub issue link for an Antithesis skill bug report or feedback. You review the fields and submit the issue yourself. CX Codex +1 521installs test:triage test:triage is a Claude Code skill that rehearses antithesis-triage: sub-agents triage live Antithesis runs, and the orchestrator audits their traces for bugs and protocol slips. CX Codex +1 406installs antithesis-setup-k8s antithesis-setup-k8s generates a trimmed set of plain Kubernetes manifests from Helm or Kustomize setups to prepare your system for testing in Antithesis. CX Codex +1 351installs antithesis-mutation-testing antithesis-mutation-testing — a skill for Claude Code, Codex, Cursor and other agents that checks whether your Antithesis property catalog can actually catch bugs. CX Codex +1 169installs antithesis-review-inputs The antithesis-review-inputs Claude Code skill assesses whether a workload’s input generation explores varied system behavior. Run it to review whether randomness is limiting bug discovery. CX Codex +1 152installs

Project sponsors

Companies that keep this analytics open