/digital-product

The eight stages

These are numbered because the order is real: each stage consumes what earlier stages produce. That is a default dependency order, not a mandate to run all eight — and work enters wherever your situation already is. A running product asking "why is churn up" enters at Improve and skips nothing that matters.

Where you enter is set by what exists, not by the numbers. Idea and nothing built → Define. A spec but no design or system → Design and Shape, concurrently. An inherited codebase with no docs → Shape first, which reads the current state as the state to evolve and says plainly what is undocumented. A diagnosis question does not restart the lifecycle.

The fourteen skills

Each one is an independently installable agent skill with its own router, its own references, and its own guide — built and released on its own before this composer existed. The shape of this map is the family's real shape: Build carries five peers, Assure and Run carry one each. Follow any card to that skill's site.

Install only what you need. Each one installs on its own with npx skills add gabros20/<pack>-skill -g -y, and works with no composer present. The composer detects what is installed and names the exact command for anything missing, then continues with what exists. There is a one-command family installer with lifecycle-shaped sets — --set core, --set build, --set all — but all fourteen is a real cost, not a free default: roughly 2.4k tokens of always-on skill descriptions in every session, whether or not a stage ever reaches them.

What it leaves out

The composer's job is subtraction. A fourteen-skill plan for a landing page is the composer failing, not being thorough. Four honest minimal paths, with every stage it does not run named and reasoned — because a stage nobody mentions reads as coverage that never happened.

What the composer itself does

It produces routing decisions, stage plans, ledger entries, and handoff glue. Never a PRD, a design, a line of production code, a test verdict, or a forecast. The moment work becomes domain work, the named specialist does it — in that pack's own voice, loaded at that moment and not before.

Stage: Assure
Entry: Define — an idea, nothing built
Skipped: Improve — no users yet
Decisions: one line, owner pack
Artifacts: path — draft | agreed |
          superseded by <path>
Next: one concrete action

• Route to one skill when one sufficesComposition is overhead. The composer's first duty is knowing when it is not needed.
• The ledger is the memoryAppended before moving on. On resume, trust the ledger and the disk over recollection.
• Seams come from the registryA ruled seam is cited with its date; a contested seam is presented as contested.
• Artifacts on disk are the interfaceA stage hands the next stage file paths, never a summary that replaces the artifact.
• Never absorb a specialist's knowledgeIf an answer needs a pack's content, load that pack — don't paraphrase it from a routing table.
• State what was skippedA plan names the stages deliberately not run, and why. A silent skip reads as coverage that never happened.

Coordination, at the lowest cost that fits

Escalate only on demonstrated need, never on ceremony. The chosen mode and its one-line justification go in the ledger.

After any mode, the ledger is reconciled from the disk — not from the report. Updating state from a summary records artifacts that may not exist. Two dispatch rules travel with mode 2: pin a model on every dispatch, and never spawn a duplicate of a running stage-agent — check its disk output first, then nudge once.

Start here

Install the composer, then the specialists you actually need. It's a plain SKILL.md router — no flags, no config, no fixed pipeline — so it activates on ordinary phrasing rather than a fixed command.

The same install runs on any Agent Skills host. Codex triggers with $digital-product; a manual copy into any client's skills directory also works.