Skip to main content
ClaudeWave
EN, English
Skill755 repo starsupdated 7d ago

develop-spike-summary

The develop-spike-summary skill documents findings from a time-boxed technical or design exploration after completion. Use it to capture investigation results, learnings, and recommendations so the team can make informed decisions about technology choices, feasibility, or proof-of-concept work without repeating explanations. This skill is distinct from architecture decisions (which use develop-adr) and solution proposals (which use develop-solution-brief).

Install in Claude Code
Copy
git clone --depth 1 https://github.com/product-on-purpose/pm-skills /tmp/develop-spike-summary && cp -r /tmp/develop-spike-summary/skills/develop-spike-summary ~/.claude/skills/develop-spike-summary
Then start a new Claude Code session; the skill loads automatically.

SKILL.md

<!-- PM-Skills | https://github.com/product-on-purpose/pm-skills | Apache 2.0 -->
# Spike Summary

A spike summary documents the results of a time-boxed exploration - a focused investigation to reduce uncertainty before committing to implementation. Spikes answer specific questions like "Can we integrate with this API?" or "Is this technology viable for our use case?" The summary captures findings so the team can make informed decisions without the spike participants needing to repeat explanations.

## When to Use

- After completing a time-boxed technical exploration
- When evaluating technology choices or vendor options
- After proof-of-concept work that needs to inform team decisions
- When investigating feasibility of a proposed solution
- Before committing engineering resources to a new approach

## When NOT to Use

- You are recording the resulting architecture decision itself -> use `develop-adr`; the spike informs, the ADR decides
- The exploration was user research, not technical or design feasibility -> use `discover-interview-synthesis`
- You want to propose the solution the spike pointed to -> use `develop-solution-brief`
- The spike has not happened yet: this skill documents results; time-box and run the exploration first

## Instructions

When asked to document a spike, follow these steps:

1. **State the Question Clearly**
   Articulate the specific question the spike was designed to answer. Good spike questions are focused and answerable with the time-box available. If the question evolved during the spike, document both the original and final versions.

2. **Define the Time-Box**
   Document the time allocated (e.g., 3 days) and actual time spent. If the spike exceeded its time-box, explain why and note any remaining work.

3. **Describe the Approach**
   Explain what was tried, in what order, and why. This helps future readers understand the methodology and whether alternative approaches were considered.

4. **Present Findings with Evidence**
   Document what was learned, supported by concrete evidence - code samples, performance benchmarks, screenshots, or API responses. Distinguish between verified findings and hypotheses that need more testing.

5. **Make a Clear Recommendation**
   Answer the original question directly: proceed, do not proceed, or proceed with conditions. Avoid hedging - the team needs actionable guidance.

6. **Document Artifacts**
   Link to any code, prototypes, diagrams, or documentation created during the spike. These artifacts often have ongoing value beyond the summary.

7. **Capture Open Questions**
   Note what the spike didn't answer and what additional investigation might be needed.

## Output Format

Use the template in `references/TEMPLATE.md` to structure the output. A complete spike summary fills every template section: Overview; Background; Approach; Findings; Recommendation; Artifacts; Open Questions; and Follow-up Items.

## Quality Checklist

Before finalizing, verify:

- [ ] Original question is clearly stated
- [ ] Time-box is documented (allocated vs. actual)
- [ ] Findings are supported by evidence, not just opinions
- [ ] Recommendation directly answers the question
- [ ] Artifacts (code, diagrams) are linked or attached
- [ ] Open questions identify remaining unknowns

## Examples

See `references/EXAMPLE.md` for a completed example.
chainSlash Command

Run an ad-hoc ordered chain of pm-skills with shared context (ephemeral; routes to the pm-workflow-orchestrator)

define-hypothesisSkill

Defines a testable hypothesis with clear success metrics and a validation approach. Use when forming assumptions to test or aligning a team on what success looks like, before any experiment is designed. To design the A/B test or experiment that will validate the hypothesis, use measure-experiment-design.

define-jtbd-canvasSkill

Creates a Jobs to be Done canvas capturing the functional, emotional, and social dimensions of a customer job. Use when deeply understanding customer motivations, designing for jobs, or reframing product positioning.

define-opportunity-treeSkill

Creates an opportunity solution tree connecting a desired outcome to customer opportunities and candidate solutions, preventing solution-first jumps in continuous discovery. Use when structuring scattered feature ideas or communicating how the roadmap traces to outcomes. For ranking an existing flat list of candidates, use define-prioritization-framework instead; this skill discovers the list, it does not score one.

define-prioritization-frameworkSkill

Run applicable prioritization frameworks (RICE, ICE, MoSCoW, Weighted Scoring, Kano) against a list of features or initiatives. Produces a comparison table showing where rankings agree and diverge across frameworks, and an executive summary with recommendation. Framework applicability is filtered by data availability; Kano requires customer research. Refuses to fabricate scores; produces an estimation scaffold when input data is missing.

define-problem-statementSkill

Creates a clear problem framing document with user impact, business context, and success criteria. Use when starting a new initiative, realigning a drifted project, or communicating up to leadership.

deliver-acceptance-criteriaSkill

Generates structured Given/When/Then acceptance criteria for a user story or feature slice, covering the happy path, key failure scenarios, and non-functional expectations in testable form. Use when turning requirements into verifiable scenarios for engineering handoff and QA sign-off. For a dedicated catalog of boundary conditions, error states, and recovery paths across a feature, use deliver-edge-cases; to write the stories themselves, use deliver-user-stories.

deliver-edge-casesSkill

Documents edge cases, error states, boundary conditions, race conditions, and recovery paths for a feature - the systematic catalog of what can go wrong and the failure modes to design for. Use during specification to map the failure surface and ensure comprehensive coverage, or during QA planning to identify boundary and limit scenarios to test. Distinct from deliver-acceptance-criteria, which writes story-level Given/When/Then checks; this skill produces the whole-feature edge-case catalog.