spike command

Command

Exploratory spike on a throwaway branch — answer a named question with disposable code. Never merges; exits to a findings note or /ca:feature.

Invoke it

Claude Code/ca:spike

Codex$ca-spike

Pi/ca-spike

Availability is read from each shipped host catalog. Preview-only commands are marked on the page.

What it does

This is the outlet for “I need to write code to find out” rather than “I know what to build.” The work happens on a disposable branch with none of the usual process overhead — no plan, no test-first discipline, no review fleet — because the code itself is never meant to survive. What survives is the answer: once the question is settled (or the timebox runs out without one), the finding gets written down as a short note and the branch is deleted. If the answer turns out to justify building the real thing, that’s a fresh /ca:feature request that treats the spike as reference material, not as a starting diff.

Usage

/ca:spike <question to answer> [timebox]

State the question the exploration needs to answer; an optional timebox overrides the one-session default.

Example

> /ca:spike can we stream large CSV exports without loading the whole file into memory? 2 hours

Question: can a 500MB export stream to the client without a full in-memory buffer?
Timebox: 2 hours. Confirm? (y/n)
> y

Branch spike/streaming-csv-export created.
[exploration — no plan, no tdd, no review]

Timebox reached. Answer: yes, a Node stream + res.write() loop holds memory flat at ~40MB regardless
of file size; the current buffer-then-send path is the only blocker.
Findings written to .codearbiter/spikes/streaming-csv-export.md.
Branch spike/streaming-csv-export deleted.

When to reach for it

Reach for /ca:spike when you don’t yet know if an approach works. Once you do, hand the findings to /ca:feature — the implementation is written fresh, test-first, never copied from the spike branch.

Gates

Gate	When	Effect
named question	before the branch is created	a spike must restate the request as a falsifiable question plus a timebox, and you confirm it before any code is written
no merge, ever	for the lifetime of the spike branch	the branch can only end in a findings file and deletion — it is never PR’d or merged
security floor	throughout exploration	no secret leaves the approved store and no irreversible operation runs, even on disposable code

Source

Source — plugins/ca/commands/spike.md (v2.18.2)

---
description: Exploratory spike on a throwaway branch — answer a named question with disposable code. Never merges; exits to a findings note or /ca:feature.
argument-hint: "<question to answer> [timebox]"
---

# /ca:spike — exploratory spike

The sanctioned lane for "I need to write code to find out." Spike code is disposable by contract:
it never merges, never PRs, and never becomes the implementation. What survives a spike is the
*answer*, written down — the code is burned.

## Flow

1. **Name the question** — a spike without a falsifiable question is just freelancing. Restate
   `$ARGUMENTS` as the question the spike answers and the timebox (default: one session). STOP for
   the user's confirmation.
2. **Branch** — create `spike/<slug>` from the current branch. All exploratory code and experiments
   stay on it; only the completed findings file may later cross back to the parent.
3. **Explore** — no `tdd`, no plan, no review fleet. Two rules survive even here: no secret leaves
   the approved store, and no irreversible operation (prod data, destructive migration) runs from a
   spike.
4. **Exit — exactly one of:**
   - **Answered** → write the findings to `${CLAUDE_PROJECT_DIR}/.codearbiter/spikes/<slug>.md`
     (the question, what was tried, the answer, what it implies), and commit only that findings file
     on `spike/<slug>`. Return to the parent branch and run
     `git restore --source spike/<slug> -- .codearbiter/spikes/<slug>.md` to transfer only the
     committed findings file, review it, and commit that one file through `/ca:commit`; do not
     merge the spike branch. Then delete the spike branch. If the answer warrants building, hand the
     findings to `/ca:feature` — the spike file seeds
     `brainstorming` (`${CLAUDE_PLUGIN_ROOT}/skills/brainstorming/SKILL.md`); the spike code is reference material, never the implementation.
   - **Timebox expired, no answer** → record that in the findings file and use the same findings-only
     transfer before deleting the spike branch.

## Hard gate

MUST NOT merge or PR a `spike/*` branch — its only exits are a findings file and deletion. Do not
transfer spike code: the parent may receive only the committed findings file. MUST NOT copy spike
code into an implementation branch wholesale; implementation re-enters through
`/ca:feature` and `tdd`. Secret-handling and irreversibility rules hold even in a spike. Commits on
a `spike/*` branch are exempt from `commit-gate` — the exemption is safe because no spike commit is
merged and the parent may copy only the committed findings file's contents, never spike code.

## When NOT to use

- You already know what to build → `/ca:feature`.
- Diagnosing a defect → `/ca:debug` (investigation with a structured exit).
- A question answerable by reading code or docs → `/ca:btw`.

View in repo