spike

Decompose user ideas into independent feasibility spikes with given/when/then verdicts.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/matthew-johnson/hermes-agent --skill spike-matthew-johnson
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: spike
Source: https://github.com/matthew-johnson/hermes-agent/tree/main/skills/software-development/spike
Command: npx skills add https://github.com/matthew-johnson/hermes-agent --skill spike-matthew-johnson

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Throwaway experiments to validate an idea before building, enabling rapid feasibility checks without committing to production work.

Core Features & Use Cases

  • Decompose ideas into 2-5 independent feasibility spikes and document Given/When/Then verdicts to surface risks.
  • Align and plan multiple spikes before coding to optimize effort and reduce waste.
  • Iterate with lightweight artifacts and conclude with a verdict to guide the next steps.

Quick Start

Create a new spikes/NNN-descriptive-name/ with a README.md and a minimal runnable artifact, then run it to observe results.

Frequently Asked Questions about spike

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I validate an idea or architecture before committing to a full build?▼

To validate an idea before building, you can decompose it into independent feasibility spikes. This structured approach uses throwaway experiments to surface risks and deliver a clear verdict to guide real-build decisions.

What is a feasibility spike and when should I use one?▼

A feasibility spike is a throwaway experiment used to validate an idea or assess risk early. You should use spikes during early-stage product exploration or architecture scoping to check viability without committing to production work.

How do I plan multiple spikes to test different approaches?▼

You can plan multiple spikes by decomposing your idea into two to five independent experiments. Aligning and planning these spikes before coding optimizes effort and reduces waste by documenting Given/When/Then verdicts for each approach.

Can I use throwaway prototypes for early-stage product exploration?▼

Yes, throwaway prototypes are ideal for early-stage product exploration. They support a lightweight workflow with deterministic steps, allowing you to iterate with minimal runnable artifacts and conclude with a verdict to guide next steps.

What's the best way to structure a spike experiment?▼

The best way to structure a spike is to create a new directory with a descriptive name, include a README.md, and build a minimal runnable artifact. Run it to observe results and document the outcome using Given/When/Then framing.

When should I not use throwaway experiments for validation?▼

You should not use throwaway experiments when you need production-ready code or permanent features. Spikes are designed for lightweight risk assessment and feasibility checks, delivering a verdict to guide real-build decisions rather than final implementations.