Shaping & Breadboarding

Shape Up methodology for product and feature development. Use when collaboratively shaping a solution — iterating on problem definition (requirements) and solution options (shapes), breadboarding systems into affordances and wiring, and slicing into vertical implementation increments. Triggers include "shape this feature", "breadboard the system", "let's shape", "slice this into increments", "fit check", "define requirements", or any product/feature scoping discussion using Shape Up methodology.

Security Scan

The skill is an instruction-only Shape Up / breadboarding methodology guide and its requirements, files, and instructions are consistent with that purpose.

Purpose & Capability

Name and description match the provided SKILL.md and reference docs. No binaries, env vars, config paths, or external services are requested that would be unrelated to a shaping/breadboarding methodology.

Instruction Scope

Instructions are detailed and prescriptive about how to run shaping sessions (tables, fit checks, spikes, file names). They ask the agent to create files (e.g., spike-[topic].md) and to include verbatim 'Source' content and full tables without summarizing. This is coherent for the methodology but raises a privacy/data-disclosure consideration: the agent may be instructed to echo user-provided text verbatim and persist it to files if the agent implementation permits file writes.

Install Mechanism

Instruction-only skill with no install spec or code. No downloads, packages, or binaries are required.

Credentials

No environment variables, credentials, or config paths are requested. The declared requirements are appropriately minimal for the stated purpose.

Persistence & Privilege

Skill is not always-enabled and does not request elevated privileges. It contains guidance to create and maintain shaping documents, which is normal for a documentation/process skill. If the agent platform allows writing files, the skill's instructions assume writing documents but do not attempt to modify other skills or system-wide settings.

Assessment

This skill is a plain methodology pack — there are no installs or credentials requested and its content matches the Shape Up/breadboarding purpose. Things to consider before installing or using it: (1) the instructions insist on including verbatim source material and full tables without summarization — avoid pasting secrets, credentials, or sensitive logs into sessions you'll feed to the skill; (2) the guidance suggests creating files (spike-*.md, shaping docs). If your agent runtime can write files, be aware those files may persist in the agent workspace; check workspace permissions and clean up any sensitive artifacts; (3) the strict 'show full tables / never summarize' rule can lead to very large outputs that might inadvertently include private data — review outputs before sharing externally; (4) if you are concerned about autonomous runs, consider keeping the skill user-invocable only (it already is) or disabling autonomous invocation at the agent/platform level. Overall the package is internally coherent and appropriate for its stated purpose.

Structured methodology for defining problems, exploring solutions, and planning implementation. Based on Shape Up adapted for working with an LLM.

Source: rjs/shaping-skills by @rjs (Ryan Singer, author of Shape Up)

Two Skills in One

Shaping — Iterate on problem (requirements) and solution (shapes) before committing to implementation. Separates what you need from how you might build it, with fit checks to see what's solved and what isn't.

Breadboarding — Map a system into UI affordances, code affordances, and wiring. Shows what users can do and how it works underneath in one view. Good for slicing into vertical scopes.

When to Use

• Exploring a new feature or product direction
• Comparing solution approaches before building
• Mapping an existing system to understand where changes land
• Breaking a selected solution into vertical implementation slices
• Any "should we build X or Y?" discussion

Entry Points

• Start from R (Requirements) — Describe the problem, pain points, constraints. Build up requirements and let shapes emerge.
• Start from S (Shapes) — Sketch a solution already in mind. Capture it as a shape and extract requirements as you go.

No required order. R and S inform each other throughout.

Core Notation

Level	Notation	Meaning	Relationship
Requirements	R0, R1, R2...	Problem constraints	Members of set R
Shapes	A, B, C...	Solution options	Pick one from S
Components	C1, C2, C3...	Parts of a shape	Combine within shape
Alternatives	C3-A, C3-B...	Approaches to a component	Pick one per component

Phases

Shaping → Slicing

• Shaping: Explore problem/solution space, select and detail a shape
• Slicing: Break down for implementation into vertical slices with demo-able UI

Key Actions

• Populate R — Gather requirements as they emerge
• Sketch a shape — Propose a high-level approach
• Detail — Break shape into components or concrete affordances
• Check fit — Build decision matrix (R × S), binary ✅/❌ only
• Breadboard — Map to UI/Code affordances with wiring
• Spike — Investigate unknowns
• Slice — Break breadboarded shape into vertical increments

Detailed Reference

For the complete methodology, notation rules, examples, and procedures:

• Shaping reference: See references/shaping.md — Full shaping methodology including fit checks, parts, spikes, documents, multi-level consistency
• Breadboarding reference: See references/breadboarding.md — Complete breadboarding procedure, affordance tables, places, wiring, Mermaid conventions, chunking, slicing

Load the relevant reference when entering that phase of work.

Quick Reference: Fit Check Format

| Req | Requirement | Status | A | B | C |
|-----|-------------|--------|---|---|---|
| R0 | Full requirement text | Core goal | ✅ | ✅ | ✅ |
| R1 | Full requirement text | Must-have | ✅ | ❌ | ✅ |

• Always show full requirement text, never abbreviate
• Binary only: ✅ or ❌. No ⚠️ in fit checks
• Explanations go in Notes section below the table

Quick Reference: Affordance Tables

UI Affordances: # | Place | Component | Affordance | Control | Wires Out | Returns To Code Affordances: Same columns Controls: click, type, call, observe, write, render Wires Out (solid →): Control flow — calls, triggers, writes Returns To (dashed -.->): Data flow — return values, reads

Quick Reference: Slicing

• Every slice must end in demo-able UI
• Max 9 slices
• Each slice demonstrates a mechanism working
• Format: V1: Name — affordances, demo statement