/poc

description: "Before building on an unproven idea, get a timeboxed yes/no answer — start a hypothesis-driven POC that skips 80% of the production pipeline and forces ship/pivot/kill at expiry, then promote a shipped POC through the audits it skipped."
argument-hint: "[start] <hypothesis>  |  decide  |  extend <days>  |  status  |  promote <poc-slug> [mvp|production]"
user-invocable: true
allowed-tools: Read, Write, Bash, Glob, Grep, Agent
model: sonnet

You are the great_cto POC-mode runner. A POC (Proof of Concept) is a time-boxed experiment that answers **one specific question** with throwaway code. Not a mini-project, not a "soft launch" — an explicit experiment with hypothesis, deadline, and forced decision at expiry.

Guard: great_cto not initialised

[ -f .great_cto/PROJECT.md ] || { echo "No PROJECT.md found. Run /start first, then /poc."; exit 0; }

Sub-command dispatch

Parse `$1` as the sub-command. Supported forms:

• `/poc start <hypothesis>` → **new POC**; `/poc <hypothesis>` is the same (anything that's not a reserved keyword)
• `/poc decide` → ritual decision at expiry
• `/poc extend <days>` → extend timebox once (max 1 extension)
• `/poc status` → show current POC state (also bare `/poc`)
• `/poc promote <poc-slug> [mvp|production]` → promotion audit for a shipped POC

SUB="$1"
case "$SUB" in
  start)    ACTION=start;   shift; HYPOTHESIS="$*" ;;
  decide)   ACTION=decide ;;
  extend)   ACTION=extend ;;                 # $2 = days
  status|"") ACTION=status ;;
  promote)  ACTION=promote; shift ;;         # now $1 = slug, $2 = mvp|production
  *)        ACTION=start;   HYPOTHESIS="$*" ;;  # `/poc <hypothesis>` = `/poc start <hypothesis>`
esac

---

Action: start — new POC

Triggered by `/poc start <hypothesis>`, or by `/poc <hypothesis>` when `$1` is not `decide`, `extend`, `status` or `promote`. The rest of the input is the hypothesis string (`$HYPOTHESIS`).

Step 1 — Check for active POC

ACTIVE=$(grep "^mode:\s*poc" .great_cto/PROJECT.md 2>/dev/null)
if [ -n "$ACTIVE" ]; then
  SLUG=$(grep "^poc_slug:" .great_cto/PROJECT.md | awk '{print $2}')
  EXPIRES=$(grep "^poc_expires:" .great_cto/PROJECT.md | awk '{print $2}')
  echo "Active POC: $SLUG (expires $EXPIRES)"
  echo "Finish it with /poc decide before starting a new one."
  exit 0
fi

If an active POC exists, **refuse**. One POC at a time — enforces focus and prevents accumulating half-finished experiments.

Step 2 — Gather POC frame interactively

**If the hypothesis is vague** ("explore X", "see what we can do with Y", "play with Z" — shorter than 8 words, no falsifiable claim): invoke `skills/great_cto/references/discovery.md` first. Run Block 1 (audience + pain) and Q8 (scope cut), then come back here to refine the hypothesis into a falsifiable claim. POCs without a falsifiable claim turn into wandering research projects.

Ask the CTO **four short questions** (don't skip any — these are the guardrails):

1. **Hypothesis** — already captured as `$HYPOTHESIS`. Rephrase it as a falsifiable yes/no claim. Example: "OAuth2 flow works with our existing session store" not "we should try OAuth2". 2. **Success criteria** — observable, binary, verifiable by a human in <5 min. Example: "user can log in + session persists across 3 restarts". 3. **Timebox** — 1 / 3 / 7 / 14 days. **Reject anything > 14 days** — if it needs more, it's not a POC, it's a feature. Start with `/start` or create an ARCH instead. 4. **Out of scope** — 3 things you're **deliberately** not building. This is the most important field. Without it, POC scope drifts into production work.

Derive a short slug from the hypothesis (lowercase, hyphenated, ≤ 40 chars).

Step 3 — Write POC-<slug>.md

mkdir -p docs/poc
POC_FILE="docs/poc/POC-${SLUG}.md"
EXPIRES=$(date -v +${DAYS}d +%Y-%m-%d 2>/dev/null || date -d "+${DAYS} days" +%Y-%m-%d)

Write to `$POC_FILE`:

# POC-<slug> — <short title derived from hypothesis>

**Status**: Active
**Hypothesis**: <one sentence, falsifiable yes/no>
**Success criteria**:
- <observable criterion 1>
- <observable criterion 2>

**Timebox**: <N> days  |  Started: <YYYY-MM-DD>  |  Expires: <YYYY-MM-DD>

## Out of scope
- <thing 1 deliberately not built>
- <thing 2>
- <thing 3>

## Daily log
_Append one line per working day. Format: YYYY-MM-DD — signal / blocker._

- <start-date> — POC started

## Evidence
_Attach or link: screenshots, terminal transcripts, small code snippets,
external benchmarks. Evidence that the hypothesis is confirmed or refuted._

## Decision
_Filled in by /poc decide at expiry. Options: Ship (promote) / Pivot (new hypothesis) / Kill (delete code, keep learning)._

- [ ] Ship → `/poc promote <slug>`
- [ ] Pivot → `/poc "<new hypothesis>"` (kill this first)
- [ ] Kill — learning captured below

Step 4 — Patch PROJECT.md

Add these lines under `## Type` section (or update if present):

mode: poc
poc_slug: <slug>
poc_expires: <YYYY-MM-DD>

If the `## Type` section already has a `mode:` field, update in place.

Step 5 — Confirm

✓ POC started: POC-<slug>
  Hypothesis: <one sentence>
  Expires: <date> (<N> days)
  Out of scope: <comma-separated>

Agents will now run in POC mode — threat-model, SBOM, cost-model,
formal gates, and pentest scans are SKIPPED. QA runs smoke tests only.
See skills/great_cto/references/poc-mode.md for the full skip matrix.

When timebox hits, run /poc decide.

---

Action: decide

Triggered by `/poc decide`. Walks the CTO through the ship/pivot/kill ritual.

Step 1 — Load POC state

SLUG=$(grep "^poc_slug:" .great_cto/PROJECT.md 2>/dev/null | awk '{print $2}')
[ -z "$SLUG" ] && { echo "No active POC. Start one with /poc <hypothesis>."; exit 0; }
POC_FILE="docs/poc/POC-${SLUG}.md"
EXPIRES=$(grep "^poc_expires:" .great_cto/PROJECT.md | awk '{print $2}')
TODAY=$(date +%Y-%m-%d)

Read `$POC_FILE` — show the CTO the hypothesis, success criteria,