Use it when you'll work with an agent here regularly and want it to follow the board's conventions without being told. Use them alongside the CLI or MCP.

How they work

A skill is a Markdown file of instructions that an agent loads when the task matches. The guide tells an agent how to make each call; the skills tell it how to work well: what to pick up next, what belongs on the wiki rather than in a comment, and how to leave a record someone will want to read.

They contain nothing about your own boards. Board names, lists and tags come from the guide for each caller, so renaming a list never makes a skill wrong.

What you get

  • slipdock: the command and API reference.
  • slipdock-work: working from a board, with epics, subcards and what to pick up next.
  • slipdock-wiki: finding, reading, writing and linking wiki pages.
  • slipdock-docs: what's worth writing down, and where it belongs.
  • slipdock-plan: planning. Asked to plan ("I want to build…", "break this into cards"), it follows the board's handbook Playbook: it sizes the ask as a card, a feature or a system, then runs the stages that size takes (grill, spike, decide, principles, spec, cards) and writes Decisions, Principles, the spec on the epic and the cards. A question only building can answer becomes a spike subcard you confirm, and planning stops until the spikes are answered: the server then asks you to resume, and the Spec is written from their answers. A one-sentence ask stays one card, and a board with no handbook is offered one. For a stage whose Playbook section names a skill (skill: grilling), it uses the one enabled on the board from the skills registry (its pinned text, from slipdock skills board), else one installed on the machine, else its own text, and says which.
  • slipdock-loop: working the To Do list unattended, one card per pass, from /loop or a schedule. It watches the build after each push and never closes a card while the build is red.

Install them for Claude Code

Into ~/.claude/skills, on any machine with curl and tar. This installs the skills only; the CLI is /cli/install.sh. This also saves this server's address in ~/.config/slipdock/url. It doesn't sign anything in.

curl -fsSL https://app.slipdock.us/install.sh | sh

On Windows, in PowerShell (not WSL, whose home folder Claude on Windows doesn't read):

irm https://app.slipdock.us/install.ps1 | iex

Want to read the script first? curl https://app.slipdock.us/install.sh prints it. The skills are also available as a tar.gz and as a JSON listing. They're versioned with this server, and slipdock skills check tells you if your copy is out of date.

For ChatGPT

ChatGPT can't run commands, so each skill also comes as a zip that names the MCP tool to use instead of each command. Connect ChatGPT to https://app.slipdock.us/mcp first, then upload the zips you want:

There's no slipdock-loop zip, because that skill commits, pushes and watches builds, and a chat can't do any of those.

Skills that come with a Tool

A Tool brings skills of its own, alongside a board. Its page has them for each client: one command for Claude Code (slipdock tools install <name>), and a zip per skill for claude.ai's and ChatGPT's skill upload. A Tool's setup skill calls install_tool over MCP, which has the server build the board — lists, folders, tags, page skeletons and rules — and answers with its code; the skill then fills the pages in with you. list_tools says which Tools you can install and which board each install made, which is how a Tool's skills find their board; with file it reads one file of the Tool, from its newest version, so a skill can fetch its own steps as it runs (skill alone reads that skill's SKILL.md), and with link: true it gives a single-use download link to the file, the skill's zip or every skill at once, for a shell with no API token; package: true links the whole package instead, every file at its path, which slipdock tools download also saves.

A Tool is a folder with tool.json, README.md, an optional board.json, skills/<name>/SKILL.md and an optional files/, published with slipdock tools publish. The package has the details.

Names worth keeping

The skills and the guide ask for card titles of about 60 characters at most, a series as <Series> <n>: <what>, with the detail in the description. A title becomes a folder in a synced vault, and a page written for a card sits in that folder, so it needn't repeat the card's title.

The handbook

One Tool is built in. slipdock tools install-board handbook --board B (or install_tool with board) gives a board's root a Handbook/ folder: pages for the specification, architecture, UX, components, data model, shared modules, testing, operations, principles (the tie-breakers, each a PRIN rule) and the playbook (how an idea becomes cards on the board), one page per decision, and an Index that lists them, plus a card that drafts them from the code and a weekly one that catches drift.

You write no instructions for it. On that board every card a pass reads (slipdock card, get_card) carries a Handbook block: the sections to read before building, picked from the card's title, description and the paths it names. Before closing, the loop runs a docs gate against the diff and leaves a Handbook: line in its closing comment — what it updated, or no change (why). slipdock handbook <board> prints the index.

The rule that a change is written up everywhere a reader would look (SPEC-10) is checked by enumeration, not judged. For a card whose paths fall in its scope, the verifier takes the names the diff introduces or alters (commands, flags, tool names, settings, page names), greps them across the seven places (the README, the manual, this help, docs/agents.md, the API guide and the skills) and gives each one result: updated, deferred to a card whose bar names that place, not applicable with why, or missing. One missing is the rule broken. The builder is told the same, so a place its paths can't reach goes on the deferral card's bar by name; a deferral whose bar doesn't list the place doesn't count.

On a board that audits accepted work (Audit 1 in N accepted cards), the verifier's prompt also carries what audits on this board caught recently: the last five audit disagreements of the last 30 days, newest first, each the rework card's title and the parts it failed. The verifier is told to check those first on the card in front of it. A miss stays on the list after its rework is done, since the lesson is the miss, and keeps the date the audit disagreed even when its finding is triaged. The audit's own prompt never carries the list, so an auditor judges afresh.