officialunofficial-skills

Plugin officialunofficial-skills from marketplace officialunofficial-skills in officialunofficial/skills. Commands read from the repo's manifest — 7 days ago.

Skills (43)

• audit-issue

  Audit an issue tree (issue + epic + siblings) for continued relevance — verify its claims against HEAD, then recommend keep, rescope, or close, with drafted comments the user can apply.

• best-practices

  Check a language, framework, or library's current idiomatic patterns against its own docs and style guides, then answer directly or review given code against them. Use when the user asks what's idiomatic, whether something is best practice, or wants code checked against current stack conventions.

• code-review

  Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/PRD asked for?). Runs both reviews in parallel sub-agents and reports them s

• codebase-design

  Shared vocabulary and principles for designing deep modules. Use when the user wants to design or refine a module's interface, hunt for deepening opportunities, decide where a seam belongs, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

• dependency-update-loop

  Recurring maintenance pass over automated dependency-bump PRs (Dependabot, Renovate, or similar) — rebase, relock, verify, and report what's ready to merge. Meant to be handed to a time-based loop or schedule, not run once.

• deploy-verify-loop

  Post-deploy verification loop — poll a rollout until every instance is on the new version and healthy, then run one smoke check against a real user path. Meant to be handed to a time-based loop with a timeout, not polled by hand.

• designing-loops

  Reference for designing agent loops — cycles of work that repeat until a stop condition is met. Covers the four loop shapes, writing completion criteria, carrying state and isolating work across cycles, and what running unattended still leaves on you.

• diagnosing-bugs

  Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.

• domain-modeling

  Actively build and refine a project's domain model as you design. Use when the user wants to nail down domain terminology or a ubiquitous language, capture an architectural decision as an ADR, or when another skill needs to keep the domain model current.

• grill-with-docs

  A relentless interview that sharpens a plan while writing the domain model down as you go — glossary terms and ADRs captured inline.

• implement

  Implement a piece of work based on a PRD or set of issues.

• improve-codebase-architecture

  Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

• latest-docs

  Fetch a library or framework's current official docs and changelog on the spot, then report what changed from what training data or existing code assumes. Use when the user names a specific library and asks to check the latest docs, verify the current API, or confirm code isn't calling a deprecated

• prototype

  Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

• research

  Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.

• resolving-merge-conflicts

  Use when you need to resolve an in-progress git merge/rebase conflict.

• setup-skills

  Configure this repo for the engineering skills — set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.

• stacked-pr-loop

  Recurring check-in on a stack of dependent PRs — rebase children onto updated parents, surface CI state, flag anything waiting on a human-only gate, and report only what changed since last time. Meant to be handed to a time-based loop, not run once.

• tdd

  Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.

• to-conformance

  Distill a conformance suite out of a spec and the current conversation — every normative requirement turned into an implementation-independent test any conforming implementation must pass — and write it to an in-repo doc. Use when the user wants conformance tests, a spec compliance suite, test vecto

• to-fuzz

  Distill a fuzzing plan out of the current conversation and codebase — the targets worth fuzzing, each with its entry point, input model, and failure oracle — and write it to an in-repo doc. Use when the user wants to fuzz-test something, harden a parser or decoder against untrusted input, find crash

• to-invariants

  Distill the invariants — properties that must always hold — out of the current conversation and codebase, and write them to an in-repo doc. Use when the user wants to capture invariants, pin down what must always be true, harden a design, or turn a discussion/spec/PRD into checkable properties.

• to-issues

  Break a plan, spec, or PRD into independently-grabbable issues on the project issue tracker using tracer-bullet vertical slices.

• to-prd

  Turn the current conversation into a PRD and publish it to the project issue tracker — no interview, just synthesis of what you've already discussed.

• to-primitives

  Abstract a feature, user story, or flow into the capability primitives it rests on, graded against the current codebase, ending in an in-repo design doc with a build-order graph. Use when the user wants to decompose a feature into capabilities, check what a feature needs against what the codebase al

• triage

  Move issues and external PRs through a state machine of triage roles — categorise, verify, grill if needed, and write agent-ready briefs.

• typesafe-ai

  Build AI-powered software with TypeSafe: small units of AI intelligence you can use like programming primitives. Its System One models, including Jev, turn natural language and application state into typed judgments and probabilities that code can combine. Use when a feature needs programmable commo

• which-skill

  Pick the skill or flow that fits your situation. A router over the skills in this repo.

• kit-attest

  Produce and verify kit attestations — in-toto v1 Statements wrapped in DSSE envelopes, attached to a signed commit. Use when attaching provenance, review, or SBOM claims to a commit, verifying attestations against a trust-roots registry, setting up co-signers, or wiring attestation into CI. Assumes

• kit-ci-preflight

  Verify a kit PR is genuinely green across its real CI surface — the GitHub Actions gates AND the Google Cloud Build `kit-*-pr` checks — before merging. Use when preparing to merge a PR into kit's `main`, when a PR looks green but you want to confirm the expected workflows actually ran, when a rustdo

• kit-release

  Cut a signed, attested kit release by driving the real tag-triggered release machinery end to end. Use when tagging a new kit version, publishing to crates.io / npm / GitHub Releases, or verifying a published release.

• kit

  Drive the `kit` CLI — a content-addressed version control tool with BLAKE3 object IDs, Ed25519-signed commits, and native in-toto/DSSE attestation. Use when working in a `.kit/` repository, making signed commits, managing signing keys, inspecting content-addressed objects, or syncing over kit+ssh/ht

• new-kit-spec

  Scaffold a new kit SPEC document with the repo's real structure, then register it in the spec index and wire any parity follow-up. Use when adding a docs/specs/SPEC-*.md for a new wire format, on-disk format, or subsystem; when an in-scope command or behavior needs a normative spec; or when a format

• git-guardrails-claude-code

  Install a Claude Code hook that stops destructive git commands (push, reset --hard, clean, branch -D, and friends) before they run. Use when the user wants to guard against dangerous git operations, add git safety hooks, or block git push/reset inside Claude Code.

• migrate-to-shoehorn

  Convert `as` type assertions in test files to @total-typescript/shoehorn helpers. Use when the user mentions shoehorn, wants to remove `as` from tests, or needs to pass partial data to a typed function under test.

• scaffold-exercises

  Scaffold an exercise directory tree — sections, problems, solutions, and explainers — that passes the course linter. Use when the user wants to scaffold exercises, stub out exercise folders, or spin up a new course section.

• setup-pre-commit

  Add a Husky pre-commit hook backed by lint-staged (Prettier), plus type checking and tests, to the current repo. Use when the user wants pre-commit hooks, wants to set up Husky or lint-staged, or wants Prettier, typecheck, and tests to run at commit time.

• grill-me

  A relentless, one-decision-at-a-time interview that sharpens a plan or design.

• grilling

  Interrogate the user's plan or design one decision at a time until you both share the same understanding. Use when the user wants to pressure-test an idea before building it, or reaches for any 'grill' trigger phrase.

• handoff

  Compact the current conversation into a handoff document for another agent to pick up.

• teach

  Teach the user a new skill or concept, within this workspace.

• technical-writing

  House style for technical writing — the voice, sentence craft, formatting, and user-facing-copy rules that make docs and product text clear, direct, and consistent. Use when writing or editing a README, docs, a spec, release notes, a changelog, help text, or any error/CLI/UI copy a person reads; whe

• writing-great-skills

  Reference for writing and editing skills well — the vocabulary and principles that make a skill predictable.