Skip to content

About

Drive structured, charter-based exploratory testing sessions in Claude Code — plan charters, run timeboxed sessions, and capture findings.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

47 Commits

Folders and files

Repository files navigation

stride-exploratory-testing

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 explorer agent 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 the explorer agent for the full boundary.

Installation

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.

Prerequisites

  • 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 explorer agent only interacts with the app you explicitly hand it.

The model

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.

What's in this plugin

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 the charter-generator agent). 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 the explorer agent 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 — /harden holds 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 with heuristics, judges results with oracles, records an SBTM session sheet, and returns structured findings (or, given EXPLORATORY_REPORT_PATH, writes them there and returns a short summary) — all under the absolute safety boundary. It runs only when the caller passes AUTHORIZED_NON_PRODUCTION: yes and an ALLOWED_HOSTS: line, and cleans up every process and file it started. It observes HTTP with curl -sS -i and judges only what its own tools can see. A charter that needs a rendered view it cannot observe ends blocked with stop_reason no_observation_surface. Its output carries contract_version, a status derived from stop_reason, and replicated / provisional on every bug. With EXPLORATORY_MODE=verify it re-checks one fixed bug from its minimal repro in one or two probes. Given an optional PROBE_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 in session_sheet.surfaces_used (contract 1.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.

Quick start

A first session, end to end:

  1. Frame the mission. Ask for charters against the feature you care about:

    /charter the CSV receipt import --risk multi-tenant data leakage
    

    You 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 import first and let the worst-case headlines drive the charters.

  2. Explore. Hand a charter to a full session:

    /explore the CSV receipt import --timebox 90
    

    --timebox is 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, --probes to change — because an agent has no honest way to measure minutes.

    The explorer agent probes the feature using the heuristics lenses, judges each result with the oracles, 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 import to map the feature and get candidate charters before committing to a full box.

    Prefer to drive yourself? Use /pair the CSV receipt import --timebox 90 instead. 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 --timebox is a real 90 minutes on your clock — the session skill's 60–120 minute box binds a paired session exactly as it binds a solo human one.

  3. Debrief. Close out with a stakeholder-ready report:

    /debrief
    

    You 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.

Session artifacts

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
  • /explore writes its aggregated debrief by default to .exploratory/sessions/<timestamp>-<target-slug>.md. Pass --output <path> to redirect that one document somewhere else. /pair writes 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. /explore adds the charters it couldn't fund and every off-charter item parked mid-session; /charter, /nightmare-headline, and /recon add the charters they generated; /pair adds the items you parked mid-session and the coverage gaps you declined; /debrief adds 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. /pair deliberately leaves it alone: its output is a session sheet, not a debrief, and the coverage fields are derived from a debrief — run /debrief on the sheet and it updates.
  • /harden stages drafted checks; it never edits your suite. Each run writes its drafts into a new .exploratory/checks/<timestamp>-<source-slug>/ directory alongside an INDEX.md recording 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.
  • /charter reads both back and hands a digest to the charter-generator agent, so run five proposes different charters than run one instead of re-suggesting ground you already covered.
  • .exploratory.md is 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 /explore offers 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.

Heuristics reference

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.

Sources & attribution

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-advocacy skill 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 oracles skill uses.

Changelog

See CHANGELOG.md. The version number is intentionally not repeated here so this README stays accurate across releases.

License

MIT — see LICENSE.

About

Drive structured, charter-based exploratory testing sessions in Claude Code — plan charters, run timeboxed sessions, and capture findings.

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages