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.