Huruikagi/pc-build-planner / .agents/skills/sb-plan
sb-plan
VerifiedPlan active Spec work through Requirements, Design, Contract Review, and Tasks, run one explicitly requested planning phase for one named Spec, or prepare explicitly scoped project shared Contracts. Ordinary Spec planning uses one named Spec or explicit all-Spec scope.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 4.6 KB |
| agents/openai.yaml | config | 195 B |
| references/complete-route.md | markdown | 19.6 KB |
| references/design.md | markdown | 30.2 KB |
| references/replan.md | markdown | 6.5 KB |
| references/requirements.md | markdown | 19.9 KB |
| references/shared-contract.md | markdown | 3.6 KB |
| references/tasks.md | markdown | 17.9 KB |
references/design.md
View on GitHub# Design phase
## Apply project language style
Before authoring any artifact or user-facing prose, read this once unless this
receiver already read it for the current `sb-plan` run:
```sh
specbind rule read language-style --for consume
```
Apply returned policy only to natural-language prose. `NO_CHANGE RULE_ABSENT`
means no additional project preference; any `ERROR` line stops the workflow.
This is the complete Design and Contract procedure selected by `sb-plan`.
Read it only for a Design phase, whether the parent is running the complete
planning workflow or the maintainer explicitly requested this phase alone.
Produce the document an implementer builds from and a reviewer judges against:
this Spec's **complete current technical design**, plus the **Contract** that
states what other Specs may rely on.
You author two artifacts and approve one gate. The requirements belong to the
phase before you, the task plan to the phase after.
## 1. Read
Always:
```sh
specbind spec status <spec>
specbind steering list
```
### Check the prerequisite first
`spec status` must report the requirements gate approved and fresh, and the Spec
a current participant of the active milestone.
A Spec that has reached the design state and has no design artifact yet reports
`State health: consistent`, `Next action: design`, and one aggregate `Expected work`
line naming the uncovered active Requirement count. That is the work you are
here to do. `check traceability` remains strict and lists each missing coverage
entry until the Design is complete.
If the requirements gate is not approved and fresh, stop and say so. Route the
user to `sb-plan` in explicit Requirements-phase mode.
Never approve or invalidate the requirements gate yourself, and never edit
`requirements.md` to make your own work possible — editing an approved artifact
invalidates its gate as a side effect, and the user gets a freshness diagnostic
instead of the decision they would have made.
### Then read the inputs
```sh
specbind artifact read <spec> requirements --for consume
specbind artifact read <spec> brief --for consume
```
The requirements are the obligation you must realize. The brief is why this
milestone is changing it.
If the Brief declares Source Items, read the shared contract once and then read
every exact project-relative item it names:
```sh
specbind protocol read source-material
```
Do not reopen the whole collection or infer neighboring files. A missing,
unreadable, unsupported, or project-external item makes the request context
partial, so stop before authoring. Requirements remains authoritative for
behavior. If a Source Item contradicts the approved Requirements, report the
Requirements rewind instead of choosing the source silently.
Read **every** steering document the listing named:
```sh
specbind steering read <selector> --for consume
```
Use only the exact selectors reported by `steering list`. Do not infer a
selector from a path or filename: in particular, the active Roadmap is not a
Steering selector and `steering read roadmap` is invalid.
Read all listed selectors, not a promising-looking subset. This is where the project's
technical guidance finally lands: the requirements phase is required to keep
technology, structure, and mechanism out of its document, so a constraint on how
this project builds things cannot have reached you through it. If you also read
selectively, that guidance reaches no authoritative artifact at all.
If `steering list` or `steering read` prints an `ERROR` line, stop. `Found 0
steering document(s).` is a complete answer and you continue.
### Read what the Spec already has
```sh
specbind artifact list <spec>
```
Read every design artifact and the contract when they exist. Read the research
when one exists — and treat it as background only. It is deleted at release and
is not fingerprinted, so a design whose meaning depends on it becomes incomplete
the moment the milestone closes. Any conclusion you need, restate here.
Source material has the same self-containment boundary. Restate every technical
conclusion the implementation or a later maintainer needs in the complete
current Design or Contract. A locator or quotation in the Brief is provenance,
not a durable design decision.
**Research marks where each of its conclusions has to land.** Those marks are
addressed to you, and the milestone deletes the document that carries them:
- **Design** or **Contract** — promote it here. That is what the mark is for.
- **Requirements** — you cannot write it. Surface it: a change to an obligation
is a requirements rewind, with the cost that carries.
- **Steering** — surface it for `sb-steering`. Do not write steering here.
- **Brief** — already routed back to the user by the analysis; nothing to do.
A mark you neither promote nor surface expires silently when the milestone
closes. If you judge one unnecessary, say so — that is a decision, and it should
be visible as one.
When an existing Contract may change a seam, resolve both sides of its current
managed graph before editing it:
```sh
specbind contract dependencies <spec>
specbind contract consumers <spec>
specbind artifact read <other-spec> contract --for consume
```
Read the Contract of every distinct Spec those two queries name. These are
direct structural relationships, not a semantic impact verdict: decide from the
actual seam whether each neighbor is affected. For a newly proposed seam, the
current graph cannot name the other side yet; use `specbind spec list` and the
investigation below to find the owning Spec, then read its Contract. Do not infer
that an empty query means there is no external consumer.
## 2. Investigate before you decide
```sh
specbind protocol read design-discovery
```
The protocol owns what must be established and when to go deeper. Read the code
you are changing rather than inferring it from names; confirm an external API
against its current source rather than from memory. A design written from
assumption produces a contract describing a seam the code does not have, and
tasks that cannot be executed as written.
A question that blocks choosing the approach is resolved or escalated now. It
cannot be deferred into the design as an open item.
Inspect the project's applicable verification command and test paths as part of
the repository investigation. Confirm that each named command exists. If it does
not, the Design must explicitly own creation of the missing script or test
interface and include that path in the change boundary. Do not describe a change
as confined to source files while relying on verification infrastructure that
the repository does not yet contain.
### Dispatch the independent parts
When the investigation is large enough that reading it all here would crowd out
the design, dispatch the independent areas as **fresh subagents** and synthesize
what comes back. Typical splits — adjust to the change rather than filling a
template:
Use the registered `specbind-researcher` role when the host provides it;
otherwise use ordinary fresh subagents. The role changes capability only; each
brief still owns its exact evidence boundary.
Fallback is only for an absent role. A configured role whose model cannot start
is a configuration or environment failure, not permission to change models.
- how the affected area works today, and what already exists to extend
- external dependencies: current API, version compatibility, constraints
- the seam: which contract entries this touches, and who consumes them
Give each one a brief that stands alone — what to establish, which paths and
identifiers to read, and what a useful answer contains — plus the protocol to
read:
```sh
specbind protocol read design-discovery
```
Require a **findings summary, not raw material**. A subagent that returns file
dumps has moved the crowding rather than removed it.
**Synthesize here, never in a subagent.** Choosing the approach needs the whole
picture, and the whole picture is what only this context has. If a returned
summary is unusable, ask once for the summary alone rather than reading around
it.
For a change that follows an established pattern in an area you already
understand, skip dispatch entirely and check the pattern directly.
## 3. Write the design
```sh
specbind protocol read design-authoring
specbind protocol read okf-authoring
```
Read the project's design and seam preferences through its rule surface:
```text
specbind rule read design-principles --for consume
specbind rule read contract-principles --for consume
specbind rule read design-template-selection --for consume
```
`NO_CHANGE RULE_ABSENT` for the design or contract principles means that
customization is absent; the protocol still applies. Design-template selection
is required because it classifies the project's complete candidate set. Any
`ERROR` line stops this workflow.
List the template set whether or not a Design already exists:
```sh
specbind template list spec
```
The listing is the complete candidate Design set and also tells you whether
each scaffold is `project` or `embedded`. Classify every listed
`design/<artifact_id>` selector using the selection rule:
- select every `required` template;
- evaluate every `conditional` template against the complete current
Requirements, existing Design set, repository facts, and explicit user
decisions;
- exclude every `disabled` template;
- ask the user when a conditional boundary remains ambiguous after those
reads; never create a precautionary empty Design.
Before writing, report each selector, its mode, and `selected` or `omitted`
with the concrete reason. A mode is not a substitute for judgment: the selected
set must still contain at least one Design, own every responsibility required by
the current change, and cover every active Requirement.
### Required Spec-local decomposition assessment
Before authoring or revising any Design, assess whether the current change needs
a Spec-local one-off supplement. Materialize one as part of the current Design
draft when all of these are true:
- a durable responsibility has its own ownership boundary and failure or
verification concern;
- no selected project candidate other than `design/main` communicates that
responsibility clearly; and
- placing it only in `design/main` would hide its independently reviewable
decisions or Requirement traceability.
Runtime deployment, configuration or Secret ownership, health signals,
dependency recovery, external API compatibility, migrations, and security
boundaries are prompts to perform this assessment, not automatic supplement
names. Record the responsibility, artifact ID, covered Requirements, target
path, and the `design/main` alternative in the Design set. This is part of
ordinary authoring, not a separate confirmation boundary, and is not permission
to create an empty precautionary document. `design/main` is the alternative to
assess, not a reason to collapse an independently reviewable responsibility
into the default document.
**No Design exists — whether the Spec is new or established** — for every
selected selector, resolve and read it:
```sh
specbind template resolve spec <spec> <design-selector>
specbind template read spec <design-selector>
```
For project file operations, write the authored document only to the reported
`Project path`, which already includes the configured SpecBind root. Do not
infer a filename from `artifact_id`, the Requirements path, or another Spec. Follow each
`create output=<name>` instruction once to produce its named output. An output
may be a short string or a Markdown fragment. Replace every reference to that
name with the same produced output, and omit the `create` instruction. Copy every
`maintain` and `consume` instruction unchanged into the live artifact. Add the
live-only traceability fields while authoring.
**A Design set exists** — read every current design artifact with
`--for maintain`, then revise those artifacts in place. If the active change
introduces a durable responsibility whose selected template has no live Design,
resolve and materialize that template. A template or rule edit by itself never
reconciles an existing Design set. If a live Design is now disabled or its
conditional responsibility no longer applies, explain the identity removal and
ask before deleting it; do not silently discard accepted design knowledge.
The design set is the Spec's **complete current design**, persistent the way the
requirements are. Fold this milestone's change into the document that owns that
concern. Do not append a milestone-shaped supplement: a reader arriving after
release must understand the system from the design set alone, with no knowledge
of which milestone contributed which paragraph.
Coverage is a separate axis. Every **active** requirement ID must be covered by
the union of the set; requirements outside the active set may stay mapped by the
existing design and are not re-argued.
Write the traceability exactly as the profile requires — a Front Matter
`requirement_ids` array of quoted YAML strings such as `"1.1"`, and an italic
`_Requirements: 1.1, 1.2_` marker beside each section that satisfies them. The
Front Matter set and the union of the body markers must match exactly.
### Splitting
One `main` document is the default. Split only when the design holds
responsibility seams a reader would follow independently, and give each
`artifact_id` a name for a durable concern rather than a slice of this
milestone's work.
When investigation shows a durable responsibility with its own ownership
boundary, failure or verification concern, and no selected project candidate
other than `design/main` that communicates it clearly, materialize a
**Spec-local one-off Design
supplement**. Do this after the candidate-set report and before writing the
complete set; do not wait for the maintainer to guess the document format in
advance.
State the assessed lowercase-kebab `artifact_id`, responsibility, covered
Requirement IDs, the alternative of extending an existing Design, and the
target `specs/<spec>/design/<artifact_id>.md` below the configured SpecBind
root in the authored set. A technology label, future possibility, or temporary
milestone slice is not enough; never create a precautionary supplement.
Read `design/main` as the scaffold shape and author the supplement at that
stated path. Replace its identity with the assessed `artifact_id`, remove every
`create` instruction, preserve `maintain` and
`consume` instructions, and add complete live traceability. It is an ordinary
live `SpecBind Design`, so include it in the complete set, checks, validation,
and gate approval. Do not add a project template or change
`design-template-selection` for this one-off decision.
If a later Spec independently needs the same focused responsibility, recommend
that `sb-configure` evaluate promotion to a project-owned conditional candidate
after the current Design phase. Do not change project configuration yourself.
Identity churn is expensive here. Adding or removing a design identity
invalidates approval by itself, so reorganizing an established Spec's design set
needs a stated reason — it is not housekeeping to do in passing.
If the design turns out to hold seams that could move separately, raise
splitting the Spec or revisiting roadmap scope with the user. Do not create or
rescope Specs yourself.
## 4. Maintain the contract
Every Spec reaching design approval has exactly one contract, and this phase is
what puts it there. A missing contract refuses approval; it is never read as an
absence of cross-spec impact.
**No contract yet** — including every Spec this milestone created:
```sh
specbind schema read contract/v1
specbind template resolve spec <spec> contract
specbind template read spec contract
```
Write the authored Contract only to the reported `Project path`; do not prepend
or remove the configured SpecBind root. The `Source` field explains whether its
scaffold is project-owned or embedded; both use the same raw read command.
A Spec with no cross-spec seams gets the canonical empty Contract: all five
entry arrays are present and empty. That is a complete and deliberate statement,
not a placeholder. Author `contract.yaml` against the versioned schema; do not
add unknown fields or use YAML comments as durable Contract meaning.
**Contract exists** — read it with `--for maintain`, then revise it in place
when this change adds, alters, or removes a seam, and leave it unchanged when it
does not. The CLI fingerprints the normalized typed Contract, so YAML formatting,
mapping order, entry order, and path order carry no meaning. IDs, descriptions,
targets, and paths do: rewording an untouched entry changes the approved seam and
forces a new contract review.
The `design-authoring` protocol carries the test for what belongs in it. Entry
IDs are stable — do not rename an ID whose meaning is unchanged, because another
Spec's `Consumes` entry resolves through it.
Removing an entry is allowed. This is not requirement retirement: a requirement
ID is an identity that design, tasks, and completion verification each have to
cover, while a contract entry's only structural dependents are other Specs'
`Consumes` entries, which resolve by name and are checked. Remove it, then let
the check and the contract review judge it.
## 5. Check before you present
For selected `_Retired_` Requirement IDs, cover the continuation or cessation
explained beside the marker, not the old behavioral promise. Inspect the baseline
when a retired group omits its former criteria. Record the resulting design and
affected Contract consumers. Historical references may remain as retirement
explanations after release; they do not restore live obligations or future scope.
```sh
specbind check traceability <spec> --for-design
specbind check contracts
```
The Design-scoped check does not read a retained downstream `tasks.yaml`; its
output says that Task coverage was not evaluated. Do not replace it with the
complete traceability check or edit Tasks during this phase. Tasks authoring and
approval will run the strict complete check after Design approval and Contract
Review.
Approval independently enforces traceability and the presence of this Spec's
Contract. Running the graph check first exposes cross-Spec diagnostics you can
act on before approval.
There is one phase-relative result during dependency-ordered reverse
establishment. If `check contracts` fails, run `specbind milestone status` and
inspect every error. You may continue only when all errors are
`CONTRACT_GRAPH_CONTRACT_UNAVAILABLE`, every source names another participant
in this same reverse milestone, and status proves each named participant is
waiting for an earlier Design dependency and is not yet actionable. The current
Spec's Contract must be readable. Report that the whole graph is provisional;
do not call the check clean. An unavailable current Contract, an unavailable
Contract outside that exact waiting set, any other error, or an unproved status
still stops this phase. The complete graph remains mandatory at the later
milestone Contract Review.
Resolve what `check contracts` reports. A reference left dangling by a removal is
either fixed in this Spec, or the consuming Spec needs owned work — which is a
scope question for the user, not something you fix. **Never edit another Spec's
contract to make your own graph clean.**
Ownership overlaps and dependency cycles are warnings, because they are
sometimes deliberate. Say why the overlap is acceptable, or treat it as a
finding. Passing it silently to contract review is not a judgment.
`CONTRACT_GRAPH_EXPORT_UNCONSUMED` is also a warning, not evidence that an
export should be removed. The managed graph cannot see external consumers:
- An existing export that this change does not alter stays semantically unchanged. Keep
its stable ID and carry the warning into the contract-review report; do not
retire an unrelated seam merely to silence the check.
- For an export this change adds or alters, name the managed or external
consumer that needs it. If there is no consumer, state the deliberate reason
the project would pay for that boundary in advance. An answer the design
cannot establish is a finding for the user, not a plausible consumer to
invent.
The later contract review owns the final cross-Spec judgment. This phase makes
its own change defensible and preserves untouched current-state contracts.
## 6. Review your own design
```sh
specbind protocol read design-validation
```
This is the same standard an independent validation would apply. A design that
would fail it is not ready to submit for approval, so apply it to your own draft
before presenting.
Report every finding with its protocol disposition:
```text
- [BLOCKING|DEFERRED|RESOLVED] <finding> — <obligation, destination, or resolution>
```
Do not leave a real observation unclassified. `RESOLVED` remains visible in the
review summary; it is evidence of what changed, not an open gate condition.
`sb-validate-design` is a separate skill. This Design-phase receiver never
invokes it, and the CLI gate does not mechanically require it. In a complete
Plan route or a Drive recovery route, return the unapproved draft to the
orchestrator: that route requires fresh independent validation before it
re-dispatches this phase with approval authority. In standalone single-phase
mode, independent validation remains an optional second opinion unless the
maintainer requested it.
Present the design, what it decided and why, and what changed in the contract.
Revise on feedback rather than approving something you know to be weak.
Stop and ask the user when the same objection survives one revision. A repeated
objection is a disagreement about intent, and rewriting again produces another
variation of the same misunderstanding.
If the objection reveals that the **requirements** are ambiguous, contradictory,
or underspecified, say so and stop. Returning to requirements is the answer;
inventing design detail that hides the gap is not. You do not perform that
rewind yourself.
An observation that is real but does not hold this gate is a **deferred**
finding under the protocol, and it needs the destination this project names:
```sh
specbind adapter read deferred --for consume
```
`NO_CHANGE ADAPTER_ABSENT` or `NO_CHANGE ADAPTER_SCAFFOLD` means there is no
destination: say so in one line and record nothing. Otherwise follow the
returned active guidance as written.
Nothing recorded there is a source of work for you; an entry re-enters this
workflow only when a person puts it on the Roadmap.
## 7. Approve
Approve only when the validation protocol's judgment is satisfied **and** you
hold authority for this gate. Authority is one of two things, never their
absence:
- **Explicit** — the user approved this design after seeing it.
- **Delegated** — a run context the user intentionally started authorized this
gate by name. The user does not confirm this document, because delegation is
exactly the decision to skip that pause. Every check still runs.
**The workflow name comes from that context. Never invent one.** If you were
told the content is pre-approved but given no workflow name, you do not have a
delegation — present your result and stop.
Never run a mutating command to find out what it accepts. Approval has no dry
run, so a probe with a placeholder value records a real approval.
```sh
specbind spec design approve <spec> --approval-mode explicit
```
A delegated run names the workflow that carries the authority:
```sh
specbind spec design approve <spec> --approval-mode delegated --delegation-workflow <workflow>
```
There are no IDs, paths, or fingerprints to pass. The CLI derives the complete
input set from the current contract and design files.
No prompt appearing, a non-interactive invocation, and a scripted run grant no
authority. Without either form, present your result and stop.
Never approve to resolve a failing check. A refused approval is information
about the artifacts; report the diagnostic rather than working around it.
## 8. Checkpoint
Only after the approval succeeds is this work eligible to commit. A draft you
have not yet approved is never committed, however often the project wants
checkpoints. If you stopped short of approving, you also stop short of this.
```sh
specbind adapter read git --for consume
```
`NO_CHANGE ADAPTER_ABSENT` or `NO_CHANGE ADAPTER_SCAFFOLD` means there is no
adapter-directed commit. Stop there — that is an answer, not a missing file to
work around.
When the adapter has guidance, follow it. The request to perform this mutating
phase authorizes the adapter's narrow local checkpoint as its ordinary final
step. It does not authorize anything broader:
- When this is the approval re-dispatch after independent validation, the
Design set, Contract, and exact active deferred-adapter destination written by
the authoring or validation dispatch are outputs of this same Design phase.
Include those reported paths with the gate-updated `spec.yaml`; fresh context
does not make the earlier Design dispatch's outputs unrelated.
- When this phase started with a proven Design-rewind delta, verify its current
lifecycle path set and diff still exactly match the captured post-invalidation
delta before approval. The approval command closes that delta by updating the
same `spec.yaml`; include the resulting gate-updated file and the proven
accepted-review removal when present in this checkpoint. Do not create a
separate invalidation checkpoint.
- An explicit user or root instruction that forbids commits wins, and tool
permissions still apply.
- Delegated approval authorizes the gate, while the orchestrated phase request
authorizes only this local checkpoint. Neither authorizes pushing.
- Commit guidance is not push guidance. Push only where the adapter says to, and
never force-push, rewrite history, or bypass a protected branch.
- Stage only the paths this run produced. Unrelated work already in the worktree
is left exactly as it is.
- Stop before the Git operation if the guidance is ambiguous, unsafe, or
conflicts with something else you were told.
A failed checkpoint does not undo or weaken the approval. The gate stays
approved; report the work as uncommitted and continue.
## When the gate is already approved
Exception: explicit Drive replan authority from [the recovery procedure](replan.md)
covers this Design rewind and reapproval. Report the full cost below, then
continue without another confirmation; keep Requirements and Milestone scope
fixed. Independent Design validation still precedes delegated reapproval.
If `spec status` shows the design gate approved, do not edit. Editing underneath
an approved gate leaves evidence describing a revision that no longer exists, and
the CLI then refuses later gates citing freshness rather than the edit that
caused it.
State the full cost and run it only after the user confirms:
- it clears the design, tasks, and completion evidence for this Spec, **and**
- it **deletes the accepted contract review** for the whole milestone, because
that review is accepted after design approval and cannot survive a rewind past
it.
The second one is the part a user will not know to expect. Say it before you
ask.
```sh
specbind spec design invalidate <spec>
```
Before the command, record `git status --short` and require the target
`spec.yaml` and accepted-review path to have no pre-existing change. Immediately
after success, record `specbind spec status <spec>`, the exact lifecycle
changed-path set, and its Git diff. Report those paths and diff as the
Design-rewind delta so Plan
can verify and carry it through independent validation. Do not edit, discard,
stash, or checkpoint the delta by itself.
Outside that explicit Drive recovery, confirmation cannot be inferred, and
ordinary delegated authority does not cover this. Ordinary delegation
authorizes accepting gates, not discarding accepted work.
## Boundaries
- Author the design set and **this** Spec's contract. Requirements belong to the
previous phase, `tasks.yaml` to the next, and brownfield comparison and
research to `sb-gap-analysis`.
- Write no machine state. Never edit `spec.yaml`.
- Do not accept the contract review, add roadmap items, or create Specs.
Surface the need and let the owning operation perform it.
- Do not author research, and do not park an unresolved design gap there.
- Report in the project's language: what the design decides, how it realizes each
active requirement, what changed in the contract, whether the work was
committed, and what runs next.
## Shared resources
Use `specbind contract shared read` when Design touches project shared resources.
Declare persistent use through `contract/v2` consumes targets
`{shared: true, section: resources, id: <resource-id>}`. Read
`specbind schema read contract/v2` before upgrading that Spec's Contract; retain
v1 for Specs that do not need shared references. A Task may change its feature's
keys in a shared catalog without duplicating file_ownership. Shared resources
are not implementation-order dependencies. If the shared agreement itself must
change, return its scoped preparation to `sb-plan --shared`; keep independent
behavior in its owning Spec. Existing project templates remain project-owned.
## Durable responsibility descriptions
Every newly authored Design has a non-empty single-line Front Matter
`description` naming its lasting technical decision boundary. On template
materialization, carry the template's literal description into the live Design;
if an old project-owned template lacks one, establish the responsibility before
materializing. For a Spec-local one-off Design, record the independently assessed
responsibility as its description along with its artifact ID and Requirement
coverage; do not add a project template or change `design-template-selection`.
Update a live description with its body only when its responsibility changes.
Existing descriptions need not change for ordinary design-detail edits, and
missing descriptions in existing major-one artifacts remain readable.
Before presenting a newly materialized Design draft, verify every new document
against the exact selected scaffold:
```sh
specbind artifact check <spec> <design-selector> --template <template-selector>
```
For a one-off supplement, use its live selector and `--template design/main`.
The check requires its own valid description while preserving durable scaffold
instructions. For unchanged template identities, it also checks literal
description inheritance. Repair reported creation faults before presenting the
draft; do not use this creation check as a provenance claim for existing Designs.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |