Testery for Claude Code
AI writes the tests. Testery orchestrates them — fast and flake-free.
Your AI agent writes the code and the tests. Testery runs them fast and flake-free on every change, gates the deploy, and is the independent audit layer so your AI doesn't grade its own homework.
Get started → • Docs • testery.io
The story
Your AI agent just refactored checkout. The diff looks clean. Ship it?
Not yet. The agent thinks the change works, but "the AI says it's fine" is not a passing test. So Claude runs the suite on Testery:
- Testery catches 2 real failures the refactor introduced and 1 flaky test it quarantines automatically, so the flake doesn't block the build or get mistaken for a real bug.
- Claude reads the failures, fixes the code, and reruns only the tests that failed instead of the whole suite.
- Testery proves the build green.
That is the Testery Loop, and it runs on every change. The agent writes the tests and the code. Testery is the independent referee that decides whether it actually works.
Why this exists
If you have shipped software with AI in the loop, you know the pain:
- Flaky tests that fail at random and train everyone to ignore red.
- "Works on my machine" that doesn't survive contact with CI.
- AI that confidently ships broken code, because the same agent that wrote the change also declared it correct.
Testery is the test orchestration and verification platform for AI-driven development. It runs your suite fast and flake-free, quarantines and retries flakes so red means red, gates the deploy, and gives you an independent audit of what the AI produced.
Don't let AI grade its own homework.
~28 slash commands. ~33 skills. One install.
Quickstart (green test in ~5 minutes)
Run these in Claude Code:
# 1. Add the marketplace (the repo path) and install the plugin
/plugin marketplace add testery/claude-plugin
/plugin install testery@testery
# 2. Connect your account (signup or token, walked through for you)
/testery-onboard
# 3. Scaffold playwright-bdd tests and wire this repo to Testery
/testery-init
# 4. Author a scenario in plain language, let AI implement it, run it
/bdd-add-scenario
/bdd-implement-code
/bdd-test
You should see a scenario go red, then green on a local run. Local runs are free and unmetered, so the first win costs nothing. When you are ready for scale, run the same suite on Testery's cloud:
/testery-create-test-run # run on Testery infrastructure
/testery-monitor-test-run # live dashboard, then a pass/fail summary
Note: the install line is always /plugin install testery@testery. The marketplace name (testery) lives in marketplace.json and is independent of the repo name, so it never changes even if the repo is renamed. Only the marketplace add line points at the repo path.
How it works: the Testery Loop
edit a plain-language AI writes the Testery runs the
feature file ───▶ code + tests ───▶ suite (fast, flake-free)
│
▲ ▼
│ catches real failures,
ship it, green quarantines flakes
and verified │
│ ▼
└────────────── AI + Testery iterate ◀──────── rerun only what failed
- Describe the behavior. Write or edit a Gherkin feature file in plain language.
- AI writes the code.
/bdd-implement-code implements the app code (not the test) to satisfy the scenario.
- Testery runs the tests. Locally for free, or on the cloud for scale. Flakes are quarantined and retried so red means red.
- Iterate to green. The AI reads real failures, fixes them, and reruns only what failed.
- Ship, verified. The deploy is gated on a green run. Verified on Testery, not assumed.
What you can do
Outcomes first. These are the jobs this plugin does, with the commands that matter most.
This is the beginning of the README. Read the rest at the original. Read the full README ↗
