Skip to content

GentBajko/capstone / skills/core

Internal to the capstone suite - carries the shared rules (references/) and scripts every capstone subcommand reads; it exists so npx-skills installs ship them alongside the command skills. Not meant to be invoked directly; when invoked anyway, run references/../scripts/help.sh and output its stdout verbatim.

FileKindSize
SKILL.mdskill md902 B
VERSIONother6 B
references/arch-craft.mdmarkdown6.6 KB
references/code-craft.mdmarkdown9.6 KB
references/core-authoring.mdmarkdown8.7 KB
references/core.mdmarkdown55.5 KB
references/dispatcher.mdmarkdown1.9 KB
references/interview.mdmarkdown17.5 KB
references/logic-craft.mdmarkdown9.5 KB
references/protocols/architecture.mdmarkdown12.2 KB
references/protocols/build.mdmarkdown10.5 KB
references/protocols/doctor.mdmarkdown9.3 KB
references/protocols/edges.mdmarkdown12.6 KB
references/protocols/feature.mdmarkdown5.3 KB
references/protocols/groom.mdmarkdown11.2 KB
references/protocols/implement.mdmarkdown15.2 KB
references/protocols/logic.mdmarkdown10.7 KB
references/protocols/map.mdmarkdown38.5 KB
references/protocols/mockup.mdmarkdown11.0 KB
references/protocols/plan.mdmarkdown9.3 KB
references/protocols/retro.mdmarkdown9.3 KB
references/protocols/review.mdmarkdown10.6 KB
references/protocols/stack.mdmarkdown8.8 KB
references/protocols/standards.mdmarkdown8.5 KB
references/protocols/start.mdmarkdown14.6 KB
references/protocols/uiux.mdmarkdown24.8 KB
references/schema.txtmarkdown11.9 KB
references/standards-inventory.mdmarkdown36.9 KB
references/style.mdmarkdown1.8 KB
references/topics.mdmarkdown21.2 KB
references/uiux-craft.mdmarkdown20.7 KB
references/uiux-inventory.mdmarkdown19.3 KB
scripts/help-hook.shexecutablescript1.5 KB
scripts/help.shexecutablescript6.4 KB
scripts/init-config.shexecutablescript16.3 KB
scripts/lint-sync.shscript133.5 KB
scripts/map-check.shexecutablescript52.8 KB

references/protocols/mockup.md

View on GitHub
# mockup - adaptive product-discovery interview, then the full mockup

**Reads:** config → `mockup-interview.md` (resume) → the existing
`mockup/` outputs when re-entering. Everything else comes from the
user.

Upstream of `architecture`: defines the product (purpose, business plan, usage
scenarios) before any architecture exists. Philosophy is the opposite of
`architecture`'s checklist-driven interview: only the seed questions are
predetermined; every question after them must be **generated from the
answers**.

## The generation rule

After each answer, ask yourself: "If I had to build the full mockup
right now, what would I have to invent?" The next question is whatever
tops that list. The interview is complete when the user says stop, or
when nothing remains that would change the mockup.

**Where it stops.** The mockup depicts; it does not decide - the
general form is core.md's Stage ownership table. When the next
question's answer would be a **rule** - a threshold, a formula, a
branch condition, who wins a conflict, what happens when something
fails - it is not this stage's to ask. Name the behavior, record the
question as an open thread addressed to `logic`, and move on. What
this stage settles is what the user sees, what they can act on, and
where that leads. A number nobody stated is never the answer to a
mockup question: `logic` asks it with the rigor it needs, and a guess
recorded here outranks nothing and contradicts everything. Where the
question is this stage's own and the answer sits with someone else -
the sales targets, the contractual SLA, what the incumbent tool costs
today - offer a questionnaire per core.md's Questionnaires section
and log the thread open.

The one exception is the **commercial model** (tiers, prices, grants,
the rate and runway equations): the business-plan angle settles it
here, and every later stage references those files rather than
restating them. It is the only arithmetic this stage decides, and the
exception ends where the money starts moving - **the price is set
here, the ledger is `logic`'s**, per core.md's Stage ownership table.
What a plan costs and what it grants is a mockup question; when a
balance is debited, reserved, refunded, or expired, what happens at
zero, and who absorbs a failed charge are all scenarios.

## Phase A - setup / resume

State lives in `docs/capstone/mockup-interview.md`, same resumable format
as `architecture`'s interview file (status frontmatter per core.md's
Interview lifecycle, numbered `### Q<n>` entries with question, answer
as given, and normalized decision, plus an `## Open threads` ledger:
seed it once with the angle areas (purpose, business plan, journeys,
behaviors), then maintain it with appends and checkbox toggles, never
whole-file rewrites; a question the generation rule's stop hands to
`logic` is logged here as an open thread marked `for: logic`, never
answered, and carried into the README's Scenarios table at Phase E).
Append each entry before asking the next
question. Resume = read the file, never re-ask. An artifact argument
(a PRD, notes, screenshots) seeds the interview per core-authoring.md's
Artifact seeding rule.

## Phase B - the seeds (the only predetermined questions)

1. "Describe the project as you would to a friend: what is it, and why
   should it exist?"
2. "Who exactly is it for, and what do they do today instead?"
3. "A year after launch, what does success look like, in numbers if you
   can?"

As soon as the answers imply it (asking directly if still unclear
after the seeds), record the product's interaction surfaces in the
interview frontmatter while working and later in the final
`mockup/README.md`: `surfaces: [web|mobile|cli|api|none]`, any
combination. `uiux` keys on the final README (no visual surface → that stage
records itself skipped), and for non-visual surfaces Phase E's
"screens" are the surface's units (endpoints, commands, message
flows): same files, same sections, the wireframe replaced by the
interaction transcript it depicts.

## Phase C - generated questions

One per turn, each derived from prior answers via the generation rule.
Angles to mine (a compass, not a checklist):

- **Purpose**: the problem, why now, non-goals, what it must never become.
- **Business plan**: who pays and how much; pricing model; market size
  and reachable slice; competition and the differentiator; acquisition
  channel; unit economics; run costs; regulatory exposure; biggest risk.
- **Journeys**: personas; the core journeys named and sequenced as
  paths through screens ("where do they land, what do they reach for,
  where does that take them?"); the first-run experience; frequency of
  use; a day-in-the-life. Walk a journey until its *screens* are
  known, not until its rules are: "then what happens?" is asked of the
  interface, and the moment the honest answer is a rule, the stop
  above applies.
- **Behaviors**: what the product must decide on its own, named but
  never settled here - resolution and authority, money and metering,
  lifecycle and recovery, membership and permission, whatever else
  this domain adds. These become Phase E's scenario inventory and
  `logic`'s question list; here they are only found, named, and
  attached to the screens they surface on.
- **Probes**: vague words → numbers **the user already knows** (price,
  audience, scale, deadline), never numbers they would invent to
  satisfy the question; contradictions between answers;
  superlatives ("simple", "seamless") → what specifically; unstated
  assumptions said back for confirmation.

Drill each answer until concrete before moving on. The user may stop at
any time; jump to Phase D and record remaining vagueness honestly.

## Phase D - the gate

Set `status: awaiting-formalization`; present the summary organized as
purpose / business plan / journeys / behaviors, plus what is still
vague and, separately, the open threads marked `for: logic` - named so
the user can see what the next stage will settle rather than mistaking
it for something forgotten. The gate is a message question per
core.md's Structured questions: the summary is the chat message, its
last line asks the user to formalize or amend, and the turn ends
there. The user formalizes or amends; do not generate until they do.

## Phase E - the mockup

On formalization, write `docs/capstone/mockup/` as **chapterized
markdown, no HTML anywhere**. One file per screen the scenarios imply,
numbered in journey order (`01-<screen>.md`, `02-<screen>.md`, …), each
with frontmatter naming the scenario(s) it serves - the logic
scenarios, by their rows in the README's Scenarios table, not the
journeys - and these sections:

- `## Layout`: an ASCII wireframe in a fenced code block plus a short
  element tree (what contains what).
- `## Elements`: every interactive element: its label, what it does,
  where it leads. The label is the working copy a wireframe cannot do
  without; register, tone, and final wording are `uiux`'s, which
  ratifies or replaces it.
- `## States`: **an inventory, not a specification.** One line per
  state the journeys imply (empty, loading, error, success, and every
  named condition this screen has): what the user sees in it, and the
  trigger *named* - never quantified, and never a decision about what
  the product does or says. "Low credits: the DM steers toward a
  stopping beat; what triggers it and whether anything is surfaced is
  `logic`'s." A state whose rule is not settled carries
  `rule: logic` inline, which is what `uiux` and `logic` both key on;
  the state is not thereby vague, it is correctly unfinished.

Every element and state must be a confirmed decision written directly
into the file; anything invented is marked "assumed" inline **and**
listed in the screen's `assumed:` frontmatter - states included, since
an invented trigger reads as settled fact to every stage downstream. A
section is never filled to look complete: `rule: logic` is the honest
entry, an invented threshold is a defect.

Inside the folder, the **only index is `README.md`**; the project
index carries the folder as one row (below). It starts with the final
product brief: purpose, audience, positioning, success measures,
interaction surfaces, commercial model, constraints, non-goals,
confirmed rationale, and every open question or deferral needed by a
later stage. It then carries three tables:

- **Screens** → the journeys served → the Scenarios-table rows it
  surfaces.
- **Journeys**: each journey as its path through the screens
  (`01 → 02 → 05`). Mockup's own unit, and what `uiux` and `build`
  order their work by.
- **Scenarios for `logic`**: the behavior inventory from Phase C, one
  row each - the behavior named, the screens it surfaces on, and the
  open threads it must settle. This table is `logic`'s question list,
  so it is written at `logic`'s unit: a thing the product decides
  ("credit metering and exhaustion", "who resolves a contested
  action"), never a route through screens. **The completeness test:**
  every state and element marked `rule: logic` anywhere in the folder
  is **owned by exactly one row**, which does not stop other rows
  referencing it - one behavior decides a rule, any number may depend
  on it, exactly as core.md's Stage ownership table draws the same
  line between stages. An unclaimed marker means the inventory is not
  finished; a marker two rows both claim to decide means the cut is
  wrong, so name the owner rather than merging two behaviors that are
  genuinely distinct. Every open thread the interview marked
  `for: logic` is carried here too, in the row of the behavior that
  settles it, or as a row of its own when none does; a thread no row
  carries means the inventory is not finished either.

All "assumed" items are collected in the README too, for the user to
review. Only after every screen file and the README are on disk,
append the changelog entry per core.md's ledger: key
`mockup/all@Q<n>`, `<n>` the highest `### Q<n>` in
`mockup-interview.md`; record the screens written with the journeys
they serve, the purpose and business-model decisions, the scenario
inventory handed to `logic`, and the vagueness the gate left open.
Then add or refresh the Companion docs row for `mockup/` in
`<index_file>`, creating a minimal index when none exists, per
core-authoring.md's Index maintenance, and only then set
`status: formalized` in the interview file (per core.md's Interview
lifecycle).

**Handoff:** (when running inside the `start` pipeline, it continues
automatically) the natural next step is `start logic`: it takes
the README's Scenarios table and settles each behavior's rules, one by
one, including every question this stage logged `for: logic`; `uiux`
then turns the screens into a committed frontend design, before any
architecture. Both stages outrank this one on anything they settle:
`logic`'s wrap replaces each `rule: logic` marker it settled with the
rule in one line and a pointer to its scenario file, and this folder
is regenerated rather than defended when the two disagree. `architecture`
(run after these) reads the formalized mockup and never re-asks what it
answers: its framing section (§0 of `../interview.md`) is largely
pre-filled by these final files.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall