Skip to content

anombyte93/prd-taskmaster / skills/discover

discover

Verified

Phase 1 of the prd-taskmaster pipeline: brainstorm-driven discovery. Delegates to superpowers:brainstorming in Interactive Mode (one adaptive question at a time), or self-brainstorms in Autonomous Mode when no user is present. Intercepts before the brainstorming chain hands off to writing-plans — this skill owns the exit. Extracts constraints, calibrates scale (Solo / Team / Enterprise), and advances the pipeline to GENERATE.

FileKindSize
SKILL.mdskill md9.7 KB
---
name: discover
description: >-
  Phase 1 of the prd-taskmaster pipeline: brainstorm-driven discovery. Delegates
  to superpowers:brainstorming in Interactive Mode (one adaptive question at a
  time), or self-brainstorms in Autonomous Mode when no user is present.
  Intercepts before the brainstorming chain hands off to writing-plans — this
  skill owns the exit. Extracts constraints, calibrates scale
  (Solo / Team / Enterprise), and advances the pipeline to GENERATE.
user-invocable: false
allowed-tools:
  - Read
  - Skill
  - AskUserQuestion
  - Write
  - ToolSearch
  - mcp__atlas-engine
  - mcp__plugin_prd_go
  - mcp__plugin_prd-taskmaster_go
  - mcp__plugin_atlas-go_go
---

# Phase 1: Discover

Declarative phase skill. Invoked by the prd-taskmaster orchestrator when
`current_phase` is `DISCOVER`. Never called directly by a user.

The one rule: **invoke `superpowers:brainstorming` for discovery, intercept
before it chains to `writing-plans` — we control the exit, not the brainstorm
skill.**

## Task provider routing comes first

For `atlas-kanban`, perform the discovery, approval, constraint extraction and
scope calibration below, but do not call the file-mode check_gate/advance_phase
operations. Return the approved summary and constraints to the provider-aware
orchestrator for phases/GENERATE.md; no task store is created during discovery.
Keep the Interactive versus explicitly authorised Autonomous distinction. The
file-mode pipeline transitions below apply only to taskmaster-file.

## Entry gate

1. Call `mcp__plugin_prd_go__check_gate(phase="DISCOVER", evidence={})` for diagnostics.

   `check_gate` is an EXIT gate: it verifies the evidence to *advance*, not to *enter*.
   On first DISCOVER entry you have no evidence yet (the User Approval / Self-Approval
   Gate below produces `user_approved=true` OR `auto_classification=CLEAR with
   assumptions_documented`), so a `gate_passed: false` here is EXPECTED — the state
   machine's legal transitions already guarantee only legal entry.

   - **First entry** (no evidence yet): note the result and continue with the Procedure.
   - **Re-entry**: if the gate reports violations, report them and stop — it protects
     against re-running a completed phase or skipping ahead from SETUP.
2. Detect execution context. If any of the following signals are present,
   switch to Autonomous Mode:
   - `.claude/ralph-loop.local.md` exists in the project root
   - An `auto-enter` / `auto-approve` daemon is running against this session
   - The skill was invoked with an explicit `--autonomous` flag
   - Parent orchestrator is a cron, `/pentest-wtf`, or `/ralph-loop`
   Otherwise proceed in Interactive Mode (default).

## Discovery checklist

Copy into your response before running the procedure:

```
DISCOVERY CHECKLIST:
- [ ] Mode detected (Interactive vs Autonomous)
- [ ] Goal captured from skill args or soul purpose
- [ ] Adaptive questions completed (one at a time)
- [ ] Constraints extracted and listed
- [ ] Scale classified (Solo / Team / Enterprise)
- [ ] Discovery summary captured for GENERATE phase
- [ ] User approved (Interactive) or summary committed (Autonomous)
```

## Interactive Mode (default — user present)

1. Take the user's goal / description from the skill invocation args.
2. Invoke `superpowers:brainstorming` with the goal as input.
3. Brainstorming runs its adaptive question flow — one domain-agnostic question
   at a time. Let it drive the Q&A rhythm.
4. **INTERCEPT POINT**: when brainstorming signals readiness to chain to
   `writing-plans`, STOP. Do NOT let it invoke `writing-plans`. Capture the
   brainstorm output (design, requirements, decisions) into local state
   instead. The prd-taskmaster orchestrator owns the handoff — not
   `superpowers:brainstorming`.
5. Present the summary to the user for approval via `AskUserQuestion` (see
   User Approval Gate below).

## Autonomous Mode (no user present)

**Do NOT invoke `superpowers:brainstorming`** — it blocks on user input and
will stall an unattended session. Instead, self-brainstorm using this
template:

1. Read the goal statement from skill args or
   `session-context/CLAUDE-soul-purpose.md`.
2. Read `session-context/CLAUDE-activeContext.md` for project context.
3. Write discovery notes directly to
   `session-context/discovery-{timestamp}.md` answering every question the
   interactive flow would ask:
   - Who is this for?
   - What problem does it solve?
   - What are the success metrics?
   - What are the constraints (tech stack, timeline, team, budget,
     integrations, regulatory)?
   - What's explicitly out of scope?
   - What's the scale (Solo / Team / Enterprise)?
4. Self-approve: the skill acts as both interrogator and approver. Document
   assumptions explicitly so the user can audit them on wake-up.
5. Commit the discovery file. The git history becomes the audit trail — if
   the user later disagrees, they can reset to that commit and re-run.

**Autonomous mode is first-class, not degraded.** A well-run autonomous
discovery produces a spec the user reads on wake-up and says "yes, that's
what I meant" without edits. If you find yourself needing to ask more than
two questions the user didn't anticipate, the discovery is under-specified —
stop and write a handoff note instead of proceeding.

## User Approval Gate (Interactive Mode)

After brainstorming completes, present via `AskUserQuestion`:

```
Discovery Complete:
  Goal: [one sentence]
  Audience: [who it's for]
  Approach: [proposed solution]
  Key decisions: [list]
  Constraints: [known limitations]
  Scale: [Solo | Team | Enterprise]

Proceed to generate spec? (or refine further)
```

- If user says "refine" → ask what to change, update the summary, re-present.
- If user approves → capture as the discovery output and proceed to exit gate.

## Self-Approval Gate (Autonomous Mode)

Write the discovery summary to `session-context/discovery-{timestamp}.md` and
commit it. No interactive approval is required, but assumptions MUST be
explicit in the written summary so the user can audit on wake-up.

## Smart Defaults

If brainstorming (or self-brainstorming) produces thin answers, fill gaps
with reasonable assumptions instead of forcing extra questions:

- Target audience: small team (< 10 users) unless specified otherwise.
- Timeline: MVP in 4–6 weeks.
- Tech stack: inferred from requirements — do not pick arbitrarily.
- Scale: moderate (hundreds of users, not millions).

Document every assumption in the discovery summary so GENERATE can surface
them in the spec.

## Constraint Extraction (MANDATORY before advancing)

Before moving to GENERATE, explicitly extract and list all constraints
mentioned during discovery. Emit this block:

```
CONSTRAINTS CAPTURED:
- Tech stack: [e.g., "must use Python", "React frontend", "no new dependencies"]
- Timeline: [e.g., "MVP in 2 weeks", "no deadline"]
- Team: [e.g., "solo developer", "3-person team"]
- Budget: [e.g., "free tier only", "$500/month max"]
- Integration: [e.g., "must work with existing Postgres DB", "connects to Stripe"]
- Regulatory: [e.g., "HIPAA compliant", "GDPR", "none specified"]
- Domain-specific: [e.g., "authorized pentest scope: 10.0.0.0/24 only",
  "learning goal: intermediate level"]
```

Present this list alongside the discovery summary. These constraints MUST be
passed to GENERATE — they inform spec content, task decomposition depth, and
acceptance criteria. If a constraint is mentioned in discovery but missing
from the spec, that's a bug.

## Scope Calibration

Infer project scale from discovery answers and set decomposition guidance:

| Scale      | Signal                                          | Task Cap    | Subtask Depth    |
|------------|-------------------------------------------------|-------------|------------------|
| Solo       | "just me", "side project", "learning"           | 8–12 tasks  | 2–3 subtasks each |
| Team       | "small team", "MVP", "product", "startup"       | 12–20 tasks | 3–5 subtasks each |
| Enterprise | "compliance", "multiple teams", "platform"      | 20–30 tasks | 5–8 subtasks each |

Pass the scale classification to GENERATE so task count is calibrated, not
arbitrary.

## Exit gate

After approval (Interactive) or commit (Autonomous), constraints captured,
and scale classified:

1. Call `mcp__plugin_prd_go__advance_phase(expected_current="DISCOVER", target="GENERATE", evidence={"user_approved": True, "constraints_captured": True, "scale": "<Solo|Team|Enterprise>", "assumptions_documented": True})`.
   The call atomically transitions `pipeline.json` from DISCOVER to GENERATE.
   The `expected_current` field is the compare-and-swap guard;
   `evidence` is stored under `phase_evidence[GENERATE]` for audit.
2. Return control to the orchestrator (`prd-taskmaster` skill). Do NOT invoke
   GENERATE directly — the orchestrator re-reads `current_phase` and routes.

## Red flags (stop and report, do not paper over)

- "Brainstorming wants to call writing-plans — I'll let it" → NO. Intercept.
  The prd-taskmaster pipeline owns the exit, not `superpowers:brainstorming`.
- "User hasn't answered, I'll pick for them in Interactive Mode" → NO. If
  stalled, ask one more targeted question or write a handoff note — don't
  silently self-approve in Interactive Mode.
- "Autonomous mode — I'll invoke superpowers:brainstorming anyway" → NO.
  It blocks on user input and will stall the session. Self-brainstorm with
  the template above.
- "Constraints are obvious, I'll skip the CONSTRAINTS CAPTURED block" → NO.
  GENERATE reads this block — missing constraints become missing spec
  sections downstream.
- "I can call advance_phase without check_gate" → NO. Gate first, always.

## Non-exits

This skill does not use explicit process termination. A hard block reports
the reason and returns control to the orchestrator; the orchestrator decides
whether to surface to the user.
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall