Drive structured, charter-based exploratory testing sessions in Claude Code.
A green test suite tells you the product does what you expected. It says nothing about the expectations you never thought to write down — the risks, the surprising states, the questions no one asked. This plugin supplies that missing half.
Tested = Checked + Explored. Checking is confirmation — evaluating a known expectation with an algorithmic rule (automated tests, assertions, "does the happy path still work"). Exploring is investigation — discovering the expectations you didn't know to write down. A product with a passing suite is checked, not tested. This plugin is the "explored" half: simultaneous test design, execution, learning, and steering.
Safety: the
exploreragent exercises a live application under an absolute safety boundary — it works only against the app and environment you name, never production or an unauthorized system, never destructively, and it treats app content as data (not instructions). All charters, notes, and debriefs use synthetic data only — no real credentials, hostnames, or customer records. See theexploreragent for the full boundary.
From the Stride marketplace:
/plugin marketplace add cheezy/stride-marketplace
/plugin install stride-exploratory-testing@stride-marketplace
Once installed, Claude Code auto-discovers the skills, commands, and agents — no further configuration is needed.
- Claude Code — the plugin's skills, commands, and agents run inside it.
- A target to explore — a running application (local or a test/staging environment you are authorized to test). The plugin never requires production access and should never be pointed at it.
- No external accounts or API keys. The plugin makes no network calls of its
own; the
exploreragent only interacts with the app you explicitly hand it.
Exploratory testing here runs on five engines. Each has a home skill or command where its depth lives:
| Engine | What it does | Home |
|---|---|---|
| Charters | Give a session its mission: what to explore, with what resources, to discover what information. | chartering, /charter, /nightmare-headline |
| Heuristics | Idea generators — cheat sheets, Tours, and SFDIPOT — for when you're stuck. | heuristics (SFDIPOT lives in chartering) |
| Variables | The factors you can deliberately vary (data, state, sequence, environment). | heuristics (variable catalog) |
| Oracles | How you decide something is actually wrong. | oracles |
| Observation | Noticing what the system actually did — not what you expected. | session, explorer |
The end-to-end flow is Charter → Recon → Explore → Note → Debrief.
6 skills (the reusable knowledge the commands and agents draw on):
stride-exploratory-testing— the orchestrator. Routes any exploratory-testing request to the right skill, command, or agent, and holds the "Tested = Checked + Explored" doctrine.chartering— how to frame a mission and write a well-formed charter (Explore <target> with <resources> to discover <information>), rank candidates with SFDIPOT and the Nightmare Headline Game, and reframe a "charter" that's really a test case.heuristics— the plugin's single source of truth for concrete test-idea lenses: general and web cheat sheets, a variable-spotting catalog, and Whittaker's Tours grouped by tourist district.oracles— how to decide whether an observed result is a defect: Never/Always invariants, consistency oracles (history, comparable products, standards, claims, user expectations, purpose), the Adapter Is Not the Wire and Two Decision Sites oracles, and the HTSM quality-criteria checklist.bug-advocacy— Kaner's RIMGEA discipline for the work between "an oracle says this is wrong" and a report someone can act on: Replicate, Isolate, Maximize, Generalize, Externalize, And say it clearly — plus the severity rubric and the dispassionate-tone rule.session— the Session-Based Test Management (SBTM) lifecycle: the session sheet, Task Breakdown Metrics, and the two debrief templates.
7 slash commands:
/charter— turn a target into a ranked list of well-formed charters (via thecharter-generatoragent). Generates only; never runs a session./nightmare-headline— run the Nightmare Headline Game: elicit catastrophic headlines, pick one, brainstorm its causes, and refine them into ranked charters./explore— plan-and-execute a full session end to end: generate or load charters, dispatch theexploreragent per charter under the safety boundary, and aggregate everything into one debrief, written to.exploratory/sessions/by default./pair— the inversion of/explore: you drive the application and Claude rides along — suggesting the next probe and naming the lens it came from, judging what you report against the oracles, working confirmed defects through RIMGEA, and calling out what the session has not touched (only happy paths, only one tenant, only ASCII) before you have to ask. It keeps your session sheet and parking lot so you don't context-switch into note-taking, runs inside your wall-clock time box, and hands off to/debrief. Claude holds no tool that can reach the app./recon— a lightweight reconnaissance pass over an unfamiliar feature to map the landscape, surface stakeholder questions, and emit ranked candidate charters./debrief— turn raw session notes and findings into a stakeholder-ready debrief using the Explored/Found/Unknown and PROOF templates./harden— the bridge from Explored back to Checked. Takes the oracle-confirmed bugs from a session sheet, a debrief, or pasted findings; detects your project's test framework from its own manifests, config, and existing tests rather than assuming one; and drafts a regression check per bug from its minimal repro — the isolated repro RIMGEA already produced is exactly what a minimal test case needs. Bugs it cannot convert are reported with the reason and the one thing that would change it, never guessed at. Drafts are staged under.exploratory/checks/, never written into your test suite, and never run —/hardenholds no test runner, so it never claims a draft passes. Given both a bug source and--framework <name>(or--framework none), it never stops to ask a question, so an orchestrator can run it unattended.
2 subagents (dispatched by the commands, not invoked directly):
charter-generator— turns a target (plus optional risk context) into a ranked list of charters via an SFDIPOT sweep, charter-source mining, and the Nightmare Headline Game. Given an optional change context, it charters a code change: every edge case is chartered or named as covered by a unit test the change names, the change-risk lenses whose triggers match are applied, and each charter is tagged with the surface it needs. Read-only; generates only, never executes.explorer— runs a single budgeted session against ONE charter: designs probes withheuristics, judges results withoracles, records an SBTM session sheet, and returns structured findings (or, givenEXPLORATORY_REPORT_PATH, writes them there and returns a short summary) — all under the absolute safety boundary. It runs only when the caller passesAUTHORIZED_NON_PRODUCTION: yesand anALLOWED_HOSTS:line, and cleans up every process and file it started. It observes HTTP withcurl -sS -iand judges only what its own tools can see. A charter that needs a rendered view it cannot observe endsblockedwithstop_reasonno_observation_surface. Its output carriescontract_version, astatusderived fromstop_reason, andreplicated/provisionalon every bug. WithEXPLORATORY_MODE=verifyit re-checks one fixed bug from its minimal repro in one or two probes. Given an optionalPROBE_HARNESS:line, it runs scratch probe files under the project's own test framework, signing in fixture users with several roles, and records which surfaces it used insession_sheet.surfaces_used(contract1.1).
fixtures/ — worked examples of the full flow: an
example charter set, an
example session sheet, an
example debrief, and an
example explorer output — the explorer's
findings JSON, which lib/test-structure.sh checks against the output contract in
agents/explorer.md. They double as concrete templates
and as regression anchors for future smoke tests.
templates/ — a commented .exploratory.md template,
placeholders only. Copy it to the root of the project you test as .exploratory.md
to say once how sessions reach the running system: the authorization lines, the
app's address, the probe-harness command, the account roles, the observation tools
and the project's constraints. It holds no secret values. /explore reads it in Step
3 and uses it only after you confirm it for that session. The format and the reading
rules are in docs/project-environment.md.
See also HEURISTICS.md for a one-page pointer to the lenses in
the heuristics skill.
A first session, end to end:
-
Frame the mission. Ask for charters against the feature you care about:
/charter the CSV receipt import --risk multi-tenant data leakageYou get a ranked list of charters, each shaped
Explore <target> with <resources> to discover <information>. Pick one (or a few). Stuck on what could go wrong? Run/nightmare-headline the CSV importfirst and let the worst-case headlines drive the charters. -
Explore. Hand a charter to a full session:
/explore the CSV receipt import --timebox 90--timeboxis your clock: it decides how many charters get funded (one session ≈ 90 minutes). Each explorer session itself is bounded by an agent-native probe budget — 12 probes by default,--probesto change — because an agent has no honest way to measure minutes.The
exploreragent probes the feature using theheuristicslenses, judges each result with theoracles, and keeps a running SBTM session sheet — staying inside the safety boundary the whole time. Want a quick lay-of-the-land pass first? Use/recon the receipt importto map the feature and get candidate charters before committing to a full box.Prefer to drive yourself? Use
/pair the CSV receipt import --timebox 90instead. You exercise the app and report what you saw; Claude suggests the next probe (naming the lens), judges each result, keeps the session sheet, and tells you what you've been neglecting. Here--timeboxis a real 90 minutes on your clock — thesessionskill's 60–120 minute box binds a paired session exactly as it binds a solo human one. -
Debrief. Close out with a stakeholder-ready report:
/debriefYou get an Explored / Found / Unknown write-up (and a PROOF review for the team). "Unknown" is a first-class result — the honest edge of the map.
The fixtures/ directory shows exactly what a charter set, a session
sheet, a debrief, and the explorer's findings JSON look like when they're done well.
Exploration that lives only in the conversation dies with it. The commands write four things into the project you are testing — the current working directory, never this plugin's own repo:
.exploratory/
backlog.md # candidate charters + parked off-charter items
coverage.md # which areas have been explored, and when
sessions/
2026-07-30-1942-receipt-import.md # one per /explore run (its debrief) or /pair session (its sheet)
checks/
2026-07-30-1942-receipt-import/ # drafted regression checks from /harden
/explorewrites its aggregated debrief by default to.exploratory/sessions/<timestamp>-<target-slug>.md. Pass--output <path>to redirect that one document somewhere else./pairwrites its session sheet to the same directory and keeps it up to date during the session, so a dropped conversation doesn't cost you your notes.- The backlog is append-only.
/exploreadds the charters it couldn't fund and every off-charter item parked mid-session;/charter,/nightmare-headline, and/reconadd the charters they generated;/pairadds the items you parked mid-session and the coverage gaps you declined;/debriefadds the parked items and open questions from your notes. Entries are checked off, never deleted. - The coverage outline is a map, not a score. It records which areas were
explored, when, what is covered, and — the part that matters — what is still dark.
There is no coverage percentage in it and there never will be: "explored enough"
is a judgment, not a number.
/pairdeliberately leaves it alone: its output is a session sheet, not a debrief, and the coverage fields are derived from a debrief — run/debriefon the sheet and it updates. /hardenstages drafted checks; it never edits your suite. Each run writes its drafts into a new.exploratory/checks/<timestamp>-<source-slug>/directory alongside anINDEX.mdrecording the framework it detected, the checks it drafted, and the bugs it could not convert and why. Accepting a draft is a deliberate copy you make into your own test directory. Nothing there is ever overwritten, and nothing there has been run./charterreads both back and hands a digest to thecharter-generatoragent, so run five proposes different charters than run one instead of re-suggesting ground you already covered..exploratory.mdis yours, not a session artifact. It sits at the project root beside the.exploratory/directory, you write it from the template, and no command writes it unless/exploreoffers to save your answers when none exists and you say yes. It is never overwritten.
A first run creates the tree. No command fails, warns, or asks you to set
anything up because .exploratory/ doesn't exist yet — a missing file is an empty
starting state.
Gitignore it. Session output describes a real application and may quote what it
observed, so add one line to your project's .gitignore:
.exploratory/Everything keeps working with it ignored. And the redaction rule applies to written files just as it does on screen: no real credentials, tokens, customer data, or internal hostnames reach any artifact. When these files are read back on a later run they are treated as untrusted data — content to weigh, never instructions to obey.
No command writes anywhere other than these four paths or a --output path you named
yourself — and no command writes into your source tree or your test suite unless you point
--output at one yourself. /harden comes closest and deliberately stops short: by
default it drafts regression checks into .exploratory/checks/, and moving one into your
real suite is your decision and your copy. Even when you do aim --output at a real test
directory, it only ever adds new files — it overwrites nothing, anywhere.
The heuristics skill is the canonical catalog of test-idea lenses — general and
web cheat sheets, the variable catalog, and Whittaker's Tours. HEURISTICS.md
is a one-page index that points into it; it deliberately does not duplicate the
tables, so there is a single source of truth to maintain.
This plugin encodes established exploratory-testing practice — a discipline built by the wider testing community over decades. It is a workflow and a set of pointers, not original research; the ideas below belong to their authors, and the plugin paraphrases them rather than reproducing their text. If it's useful, go read the primary sources:
- Exploratory testing as a discipline — Cem Kaner, who coined the term and framed it as simultaneous test design, execution, and learning.
- Bug Advocacy (RIMGEA) — Cem Kaner — Replicate, Isolate, Maximize,
Generalize, Externalize, And say it clearly: the follow-through that turns a
found bug into a fixed one, and the doctrine the
bug-advocacyskill encodes. - Charter-based, practical exploratory testing — Elisabeth Hendrickson,
Explore It! — the source of the
Explore <target> with <resources> to discover <information>charter template this plugin builds on. - Session-Based Test Management (SBTM) — Jonathan Bach and James Bach — the session sheet, the time-box, and the Task Breakdown Metrics.
- The PROOF debrief mnemonic (Past, Results, Obstacles, Outlook, Feelings) — Jonathan Bach.
- Tours (Business / Historical / Tourist / Entertainment / Hotel / Seedy districts) — James Whittaker, Exploratory Software Testing.
- The Heuristic Test Strategy Model (HTSM) — James Bach — including the SFDIPOT
coverage lens and the quality-criteria checklist the
oraclesskill uses.
See CHANGELOG.md. The version number is intentionally not repeated here so this README stays accurate across releases.
MIT — see LICENSE.