К основному содержанию
скилл CX Codex

antithesis-feature-workload — скилл для Claude Code

Скилл antithesis-feature-workload для Claude Code проектирует и создаёт автономный нагрузочный тест под конкретную фичу без использования Test Composer.

Apache-2.0 156 установок ★ 313 обновлён 2026-10-22

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add antithesishq/antithesis-skills --skill antithesis-feature-workload -a claude-code
Открыть на GitHub

Что делает antithesis-feature-workload

Скилл направляет агента при исследовании отдельной фичи в тестируемой системе (SUT). Он помогает выявить проверяемые инварианты, граничные состояния и условия сбоев, а затем сгенерировать автономный воркгруз (self-driving workload). Нагрузочный сценарий запускается одинаково локально и внутри платформы Antithesis.

Код теста строится в дуальном режиме: при наличии переменной ANTITHESIS_OUTPUT_DIR срабатывают утверждения Antithesis SDK (включая проверки достижимости Sometimes), а без неё выполняются стандартные локальные проверки. Сценарий поддерживает работу как с готовым кодом, так и с фичами в разработке через TDD-заглушки.

Для локальных прогонов требуется Docker Compose v2 и Docker или Podman. Для отправки тестов в облако Antithesis необходимы CLI snouty версии 0.8.0 или новее и установленный плагин Antithesis.

Какие задачи решает

  • спроектировать целевой нагрузочный тест под изолированную фичу
  • сформулировать инварианты и reach-проверки для Antithesis SDK
  • подготовить автономный сценарий тестирования для локального запуска в Docker
  • настроить TDD-стабы утверждений для ещё не готового функционала

Примеры запросов агенту

  • Спроектируй воркгруз Antithesis для новой фичи биллинга по спецификации
  • Добавь reach claims и проверки инвариантов для модуля авторизации
  • Подготовь автономный тест фичи для локального запуска через Docker Compose

Как установить antithesis-feature-workload

1Через Skills CLI (Vercel)

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

2Вручную: положить файлы

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

Папка скилла целиком; для одного проекта — .claude/skills/antithesis-feature-workload/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об antithesis-feature-workload

Как установить antithesis-feature-workload в Claude Code?

Выполните команду npx skills add antithesishq/antithesis-skills --skill antithesis-feature-workload -a claude-code в терминале.

Что делает antithesis-feature-workload?

Он помогает исследовать поведение отдельной фичи, определить её инварианты и написать автономный генератор нагрузки, работающий локально и в среде Antithesis.

Что нужно для работы antithesis-feature-workload?

Нужен доступ к исходному коду системы, Docker Compose v2 с Docker или Podman для локального запуска, а для облачных прогонов — утилита snouty 0.8.0+ и плагин Antithesis.

Исходный текст

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

Похожие скиллы

Все скиллы по теме «Тесты и QA» →
skillshare-implement-feature runkids Скилл skillshare-implement-feature ведёт реализацию Go-фичи от спецификации до проверок по TDD. Подходит для новых CLI-команд, флагов и внутренних пакетов. CX Codex +1 ★ 3 269звёзд репо new-feature undeadlist Скилл new-feature в Claude Code разворачивает разработку фичи по шагам: тесты, код, регрессионная проверка, при наличии UI — проверка в браузере. CX Codex +1 ★ 149звёзд репо shift-left-testing kindlmann Скилл shift-left-testing помогает перенести проверку качества на этапы планирования и написания кода. Он нужен, когда дефекты находят слишком поздно, а команде требуются сессии Three Amigos, TDD и чёткие критерии приёмки. CX Codex +1 1 300установок quality-validation qodex-ai Скилл quality-validation запрещает ИИ-агенту заявлять о готовности задачи без свежих доказательств: запусков тестов, сборки или проверки диффа в Git. CX Codex +1 142установок test-environments kindlmann Скилл test-environments для Claude Code. Помогает спроектировать уровни тестовых окружений: от локального контура и CI до preview-стендов и staging с паритетом продакшена. CX Codex +1 1 600установок development-team mvschwarz Скилл development-team организует разработку и тестирование внутри пода. Помогает агенту доводить задачу до готового кода с проверкой через открытые интерфейсы. CX Codex +1 ★ 8 928звёзд репо

Из того же набора13

Весь набор →
antithesis-setup Скилл antithesis-setup для Claude Code, Codex, Cursor, GitHub Copilot и Gemini CLI, который разворачивает docker-compose-окружение для тестовой платформы Antithesis. CX Codex +1 624установок antithesis-debug Скилл antithesis-debug запускает bash-скрипты внутри тестового прогона Antithesis в выбранный виртуальный момент времени через утилиту snouty. CX Codex +1 618установок antithesis-launch Скилл antithesis-launch для Claude Code находит конфигурацию Antithesis, собирает Docker Compose и проверяет её через snouty validate. Отправляет новый тестовый прогон из репозитория. CX Codex +1 554установок antithesis-skills-feedback Скилл antithesis-skills-feedback готовит ссылку на GitHub issue с данными об ошибке или отзыве по Antithesis skill. Пользователь проверяет форму и отправляет её сам. CX Codex +1 521установок test:triage Скилл test:triage для Claude Code проверяет antithesis-triage: субагенты триажут реальные прогоны Antithesis, а оркестратор ищет в их трассах баги и нарушения протокола. CX Codex +1 406установок antithesis-setup-k8s Скилл antithesis-setup-k8s преобразует чарты Helm, шаблоны Kustomize и манифесты Kubernetes в минимальный набор для запуска системы в окружении тестирования Antithesis. CX Codex +1 351установок antithesis-mutation-testing Скилл antithesis-mutation-testing для Claude Code, Codex, Cursor и других агентов проверяет, способны ли ваши Antithesis-свойства реально поймать баг. CX Codex +1 169установок antithesis-review-inputs Скилл antithesis-review-inputs для Claude Code оценивает, как генерация входов помогает исследовать разные состояния системы. Запускается по просьбе проверить, не ограничивает ли генерация входов поиск ошибок. CX Codex +1 152установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой