GentBajko/capstone / skills/core
core
VerifiedInternal 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.
references/protocols/standards.md
View on GitHub# standards - how code must be written here
**Reads:** config → `../standards-inventory.md`, in full, before the
first question → `standards-interview.md` (resume) → lazily, per
domain: `03-conventions.md`; the index plus `01-architecture.md` and
`05-dependencies.md`; `mockup/README.md`, never bulk-read upfront.
Elicits how code **must** be written in this project, independent of
what the code currently does. The output is normative (allowed, like
the reviews, to say "do X, never Y", because every rule is the user's
own recorded decision, not the skill's opinion).
**Standards, not conventions.** `03-conventions.md` reports what this
codebase habitually does, violations included, and `map` rewrites it
whenever the code moves. This file records what the user decided it
must do, and nothing regenerates it. Where they disagree, the code is
wrong, not this file: that gap is what `review` reports.
Interview state: `docs/capstone/standards-interview.md`, same resumable
format as the other interviews (status frontmatter per core.md's
Interview lifecycle, `### Q<n>` entries appended before the next
question, and an `## Open questions` ledger seeded once from
`../standards-inventory.md`'s domain list, maintained by appends and
toggles, never whole-file rewrites). Interview files are never indexed.
Output: `docs/capstone/standards.md`, indexed under Companion docs.
## Phase A - setup / resume
Read the interview file if it exists and is unfinished, then resume;
never re-ask. If it is formalized, read `standards.md` instead and open
the interview body only to repair a proven omission. An artifact
argument (a style guide, an existing CLAUDE.md) seeds the
interview per core-authoring.md's Artifact seeding rule.
Creating the file seeds `## Open questions` **once**, one unchecked box
per domain in `../standards-inventory.md`'s §3 order, seventeen lines
and no more; split a domain into sub-items only when part of it is
settled and part is not (`- [ ] Security - S53 advisories, S55 auth
review`). A domain the sweep rules out entirely is checked off with its
reason on the same line, so the ledger records the decision rather than
losing it.
Then ground the interview in whatever already exists, each source read
lazily, only when the current question domain touches it, and only if
present:
- The conventions topic (`docs/capstone/03-conventions.md`): ask
preference questions as confirmations of observed reality ("the code
currently uses exceptions everywhere: preference or accident?")
rather than from scratch. An entry marked
"provisional: `standards` owns this" is the architecture interview's
proposal: confirm it as a question, never copy it as settled.
- The architecture reference (index + `01-architecture.md`,
`05-dependencies.md`): the chosen stack scopes the library questions;
ask about the libraries the project actually faces, not generic ones.
- The mockup (`docs/capstone/mockup/README.md`): its Scenarios and
Journeys tables inform testing and error-handling preferences (what
must never break, what the user journey tolerates).
Never bulk-read all of these upfront; pull each in at the domain that
needs it.
## Phase B - the interview
One decision per question; offer concrete options when enumerable;
adaptive follow-ups until each answer is concrete; record the
normalized decision immediately. What a domain's sweep leaves to ask
may share a dialog per core.md's Shared dialogs; a follow-up never
does.
`../standards-inventory.md` holds the seventeen domains and the items
inside them. Each item carries the probe that turns it into a question,
the `../code-craft.md` rule it defaults to when one exists, and the
`standards.md` section its answer lands in. Read it in full before the
first question; do not read it aloud.
Run its §2 sweep per domain, as you reach that domain rather than once
at the start:
- Deduce what an earlier answer, `../code-craft.md`, or
`03-conventions.md` already settles, and record the value with its
source instead of asking. A provisional entry settles nothing; it
is asked as a confirmation.
- Batch every inapplicable item in the domain into **one**
confirmation, not one question each. A correction turns a batched
empty back into a real question.
- Ask what remains, one item per question: the independent ones
together where core.md's Shared dialogs allows, one per turn
otherwise.
Order the domains by what this project makes urgent - a payments
service earns Security and API conventions before Accessibility - and
toggle each ledger box as its domain closes. Nothing is skipped
silently: a domain the user rules out is recorded with its reason, per
the inventory's §5.
Several domains here ask what someone else decides: the compliance
regime Security answers to, the retention window Logging and privacy
needs, the release cadence Process is bound by. An item the user
cannot answer earns a questionnaire per core.md's Questionnaires
section, and its ledger box stays unchecked with the recipient named
on the line (`- [ ] Logging and privacy - retention window, sent to
the data team 2026-09-07`). An item awaiting an answer is neither
answered nor ruled out; it counts as settled for now, so the gate
stays reachable, Phase D writes it into `## Not in play` as awaited
with its recipient, and a later run picks it up from there.
**Overriding the craft file.** `../code-craft.md` governs everything
these domains leave open, and this file outranks it - but only by a
decision that *names what it overrides* (code-craft's Precedence
rule). When an answer contradicts the ladder, the TDD cycle, or the
earned-interfaces rule, record the rung or rule it replaces in the
same `### Q<n>` entry, so a later reader can tell a considered
departure from an accident. An answer that merely conflicts, without
saying so, is not an override: the ladder still stands.
## Phase C - the gate
The interview is finished when `../standards-inventory.md`'s §5 gate is
satisfied: every item answered, cited to `../code-craft.md` as accepted
unchanged, recorded inapplicable with its reason, or awaiting a
questionnaire answer. Not when nothing more comes to mind. A user who
stops pauses the stage with `status: interviewing`. When the gate is
met, set `status: awaiting-formalization`, present the decision
summary by domain, and ask the user to formalize. 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. Do not write the output until they do.
## Phase D - the output
Write `docs/capstone/standards.md`: frontmatter stamps (no
`paths_covered`: standards don't go stale with code, and no refresh
path may regenerate them); banner "Standards the user set: binding,
not a description of current code."; imperative voice.
The section list is fixed: one `## <Domain>` heading per domain in
`../standards-inventory.md`'s §3 order, then a closing
`## Not in play`. Every heading is written even when its domain was
ruled out, holding one sentence that points at the `Not in play` line
for it, so a reader who opens the file for the API rules finds an
answer where they looked. Each decision and any needed rationale goes
directly into its domain's section. `Not in play` lists every item and
every domain the sweep ruled out, one line each with the reason, then
every item still awaiting a questionnaire answer, one line each naming
the recipient and the date it was sent. Those two groups read
differently on purpose: one is settled, the other is a gap with a name
attached to it.
Then append the changelog entry per core.md's ledger: key
`standards/all@Q<n>` from the interview's highest `### Q<n>`; record
the rules decided per domain and the domains the user ruled out. Rewrite
each entry in `03-conventions.md` marked
"provisional: `standards` owns this" to the rule decided here, dropping
the marker. Update
the index per core.md, set `status: formalized`
in the interview file (only now that the output is on disk, per
core.md's Interview lifecycle), and suggest (never do unasked)
seeding the project's `AGENTS.md`/`CLAUDE.md` from it. Outputs on
disk, the `standards/all` key present and
`status: awaiting-formalization` is a finished stage whose marker was
not written: set `status: formalized`, never re-gate.
**Consumers:** an `architecture` interview that starts while this file
already exists (a re-run, or `architecture` entered after `standards`;
never in pipeline order) reads its conventions answers from it and
never re-asks; `review`'s backend side gains a
standards-divergence dimension when this file exists (the conventions
chapter measured against these rules).
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| 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: 471k | Updated | Claude CodeCodex | Verified | Install |
| 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: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| 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 available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |