dwin-skills

Plugin dwin-skills from marketplace dwin in dwin/skills. Commands read from the repo's manifest — today.

Skills (49)

• arena

  Have several agents attempt the same task, pick the strongest attempt as the base, and graft the best parts of the others into it. Use for "arena this" or when one attempt at an artifact would lock in the wrong shape.

• autopilot

  Drive a branch to a ready pull request. Keeps it current with its base, gets local review from a different model family, marks it ready, and handles CI and AI-reviewer feedback. With `merge`, also merges it. Use when the user invokes autopilot.

• babysit

  Monitor or babysit an open pull request through CI, mergeability changes, and review feedback. Use when the user asks to watch a PR, keep checking it, diagnose checks, address in-scope findings, or stay with it until it is merged, closed, or genuinely needs user input.

• blast-radius

  Find what a change can break outside its own diff, and prove the fact its safety rests on by running real code. Use when the user asks for the blast radius of a change, asks what a change could break, or wants a small diff they don't trust checked before it ships.

• catchup

  Catch the user up on work in flight in plain words, covering what changed since their last message, where each piece stands, and every decision waiting on them. Use when the user asks "where are we", "catch me up", "what's the status", or "still going?".

• code-review

  Review the changes since a fixed point (commit, branch, tag, or merge-base) along three axes — Standards (does the code follow this repo's documented coding standards?), Spec (does the code match what the originating issue/spec asked for?), and Behavior (does the change hold up when a reviewer runs

• design

  Design modules, interfaces, and seams before writing code. Use when the user wants to design or sketch a change, improve a module's interface, decide where a seam goes, or make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

• 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

  Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a CONTEXT.md, or recording or editing an ADR.

• engineering-principles

  Apply simple, type-safe engineering practices while implementing, refactoring, testing, or reviewing TypeScript, Go, or C#. Use for code-quality decisions involving scope control, durable domain models, behavior-focused tests, idiomatic language patterns, and ceremony proportional to risk.

• eval

  Measure whether a skill or a model does a set of tasks better, by correctness, corrections needed, cost, and time. Compares a skill against no skill or an earlier version, or one model against another.

• explain

  Explain a change, a subsystem, or a concept so the user understands it, or run a learning workspace for a topic studied over several sessions.

• figure-it-out

  Work through a large or unclear task to a checkable finish without stopping to ask, and leave a log the user can audit when they return. Use when the user says "figure it out", "keep going until it's done", or "I'll be away", or hands over a migration or multi-part change to run unattended.

• file-pr

  Create or update a pull request with an outcome-focused title and description. Use before running `gh pr create` or its equivalent for any reason, whether the user asked for a PR, the task ends in one, or an existing PR's title or body needs updating.

• focus-output

  Keep responses action-first, low-distraction, and easy to resume for the rest of the session. Use only when the user explicitly asks for focus mode or focused output.

• grill-me

  Start an explicit, user-invoked interview that pressure-tests the current plan, design, decision, or idea before action begins.

• grill-with-docs

  A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.

• grilling

  Interview the user rigorously about a plan, design, decision, or idea until consequential assumptions and branches are resolved. Use when the user asks to be grilled, wants their thinking challenged or pressure-tested, or another skill needs a reusable decision interview.

• handoff

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

• how

  Explain how a subsystem works, as a walkthrough built from reading its code. Use for "how does X work", "walk me through Y before I change it", or "where should this live".

• implement

  Implement a piece of work based on a spec or set of tickets.

• lookback

  Review many past sessions for repeated prompts, recurring workflows, and repeated corrections, and turn them into changes to skills, instructions, checks, or automations. Use for "look back over my sessions" or "what should I automate".

• managing-workspaces

  Manage the lifecycle of isolated task checkouts and their build storage. Use when creating or removing a Rift, Git worktree, or task clone; when a task needs a different branch than a shared checkout has; or when sizing build lanes, caches, or disk for a long build or test run.

• 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.

• recall

  Rebuild what earlier sessions said, decided, and left open on a topic, checked against the current state of the work. Use for "recall my work on X", "where did I leave off", or "what did we decide about Y".

• refactor

  Change the structure of code without changing its behavior. Use when the user asks to refactor, restructure, clean up, simplify, or deepen code, or asks what in a codebase is worth refactoring.

• 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.

• retro

  Conduct a retrospective on a coding session.

• rift

  Use Rift copy-on-write workspaces when the user requests Rift isolation, a snapshot of current working state, or Rift workspace management.

• rollout

  Follow a merged change until it is applied, live, and observed. Use after merging a change that deploys, applies infrastructure, or changes runtime behavior, when the user asks whether something is deployed or live, or before stating what a merge will do.

• rust-build

  Rust compilation caches. Use when configuring, diagnosing, or sharing sccache, shared target directories, or container and CI cache reuse, or when reducing Rust build storage across workspaces or runners.

• setup-dwin-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.

• sharpen

  Rewrite a prompt into a deeper version of the same task before it is sent, without doing the task. Use for "sharpen this prompt" or "make this ask deeper, not bigger".

• swarm

  Coordinate work done by other agents. Brief each worker, track lanes in a ledger, verify what workers report, and stay reachable until every lane is done. Use when delegating a task to another agent or model, when running two or more lanes of work in parallel, or when the user assigns models to role

• 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.

• technical-writing

  Write technical prose that a tired engineer understands on the first read. Use when writing, rewriting, or reviewing documentation, a README, a design note, a pull request description, a commit message, or a technical message for people to read.

• to-questionnaire

  Turn a decision you can't fully answer into a questionnaire for someone else to fill in.

• to-spec

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

• to-tickets

  Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native blocking links on a real tracker.

• triage

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

• unslop

  Remove the marks of machine-written prose from text while keeping every fact and the author's voice. Use when the user asks to unslop, humanize, or de-AI a draft, says text sounds like AI wrote it, or wants prose for people checked for AI tells before it is posted or sent.

• verifier

  Create a project-local skill that proves changes by driving the real app the way a user does, or bring an existing one back in line with the code. Use for "make a verify skill for this repo" or "audit the verify skill".

• verifying-claims

  Establish the state of a pull request, check, branch, secret, deployed resource, or file by observing it rather than inferring it. Use before stating that something is ready, passing, merged, deployed, configured, or absent, when relaying another agent's report, when work depends on external state,

• wait-what

  Stop. That last message did not land — re-pitch it.

• wayfinder

  Plan a huge chunk of work — more than one agent session can hold — as a shared map of decision tickets on your issue tracker, and resolve them one at a time until the way to the destination is clear.

• whats-next

  Match a task to the skill, flow, or playbook that fits it. Use when the user asks what to do next or which workflow applies, when a task fits no other skill, and for these kinds of work, which have playbooks here - proving a property of concurrent or stateful code with a model checker or verifier, m

• why

  Find out why code is the way it is from its history, reviews, tickets, docs, and other records, and say how sure each answer is. Use when the user asks why something is built, written, or behaves a certain way, why a choice was made, or where a number or limit came from.

• wizard

  Generate an interactive bash wizard that walks a human through steps only they can perform. Use when provisioning infrastructure, setting up credentials or CI secrets, walking an unfamiliar third-party dashboard, or running a one-off migration or cutover. Don't invoke this for steps the agent can pe

• writing-for-agents

  Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.

Similar plugins