Seam

  

Most AI coding tools are great once you know what you want. The hard part is everything before that — figuring out what's even worth building.

Seam is a way to design software products through exploration. Unlock your inner creativity.

• It's ok to not know what you want — as you explore options, the right shape is revealed.
• Pictures > paragraphs — make the thinking visible, then ask the one question that changes everything: "how does this feel?"
• Build a codebase you can move fast in — change one part without holding the whole thing in your head.

How it works

Seam is a workflow you enter at whatever stage matches where you are — a brand-new idea, a codebase to understand, or a settled plan to build. You won't always start at the first one:

1. Design the Product — when the look and feel are still open: make something to look at and react to.
2. Design the Code — find the seam (where the general core meets the special cases) and name the invariants worth guarding. Run over code that already exists, this is the "think through this codebase" mode.
3. Build — guard what you found, and write the tests that make you confident.

┌────────────────────────────────────────────────────────────┐
│ Design the Product                                         │
│ when there's a look or feel to react to                    │
│ explore by reacting: rendered prototypes / mockups         │
│ done when: human points at one — 'this, not that'          │
└────────────────────────────────────────────────────────────┘
                               │   a shape chosen — now design how it works
                               ▼
┌────────────────────────────────────────────────────────────┐
│ Design the Code                                            │
│ picture doc (vision · invariants · goals, one arc)         │
│ + seam map (core | shell | what crosses)                   │
│ done when: implementation could start tomorrow             │
└────────────────────────────────────────────────────────────┘
                               │   seam found + invariants worth guarding named
                               ▼
┌────────────────────────────────────────────────────────────┐
│ Build                                                      │
│ build it; guard the load-bearing invariants                │
│ + the unit tests that would make you confident             │
└────────────────────────────────────────────────────────────┘

Underneath are three bets: explore before you specify, make it visible, and care about invariants, not ritual — loose while you explore, strict once you've found what matters.

Install

Seam is a Claude Code plugin — add the marketplace and install, no cloning required:

/plugin marketplace add seanaujong/seam
/plugin install seam@seam

Claude Code reaches for it on design and exploration work, or you can invoke it by name. No Claude Code? The docs stand on their own — start here, then the method.

Use it alongside your build workflow

Seam doesn't replace your test-first or spec-driven setup — it runs upstream of it. Use Seam to figure out what to build, find the seam, and name the invariants worth guarding; then hand off to whatever builds it well — superpowers' TDD-and-review loop, GSD's spec-driven execution, or your own. The invariants you name in Seam become the first tests those workflows enforce. They co-install cleanly: Seam triggers on the design-and-explore work, your build workflow on the implementation.

Where to look

• plugins/seam/seam.md — the method itself: the bets, the standing checklist, the vocabulary.
• plugins/seam/SKILL.md — the same thing as an agent skill (the cues, not the rationale).
• plugins/seam/pure-core.md — one architecture to adopt, if you want a recommended one.
• plugins/seam/vertical-slices.md — one way to organize folders so you can move fast.
• plugins/seam/production-tax.md — a lens for "what would it cost to take this live?"
• plugins/seam/examples/typescript.md — the guards as real code.
• plugins/seam/stories/ — short field notes on why it works.

Seam never requires a particular architecture — it meets a codebase where it is. The patterns above are offered, not imposed.