Skills

Kapable ships Claude Code skills — installable capabilities that let any Claude Code agent use the platform to your taste. Drop one into ~/.claude/skills/ and invoke it by name in any session; it carries the platform's own doctrine so what it produces is on-brand, not generic scaffolding.

What a skill is

A skill is a self-contained folder with a SKILL.md (plus any bundled reference docs) that Claude Code discovers and invokes by the name: in its frontmatter. Kapable's skills are self-contained — the doctrine and examples travel with the skill — so they work installed globally or per-project, with no repo checkout required. The only thing you supply is an org API key.

Installing a skill

Skills live in ~/.claude/skills/<name>/ (global — every session) or .claude/skills/<name>/ inside a project (that project only). Install the folder, set the prerequisite env, then invoke it by name:

# 1. Install the skill folder (global — available in every Claude Code session)
cp -R kapable-artifact-publish ~/.claude/skills/

# 2. Provide an org API key with the `write` scope (minted in the Kapable console)
export KAPABLE_ORG_KEY="sk_org_…"

# 3. Invoke it in any session
#    /kapable-artifact-publish   — or just: "publish this report as a Kapable artifact"

Auth

Skills that call the platform need an sk_org_ org key — scope write to publish, read to list/read. The org is resolved from the key; you never pass an org id. A read-only key that tries to publish gets a 403. See the Authentication guide.

kapable-artifact-publish

Design and publish a beautiful, self-contained HTML artifact — a report, plan, spec, case, or brief — to your org gallery at {org}.kapable.ai/artifacts/, addressable forever and shareable with a link.

The skill carries Kapable's design doctrine (its 02-TASTE spec + a fully worked reference render) so any model, not just its author, produces a document the org is proud to share — grounded in its subject, never stamped from a house template. It sketches a design plan, writes the self-contained HTML with real content, self-validates against the publish rules locally, publishes via the Artifacts API, and returns the URL.

Invoke it with

Trigger	What happens
/kapable-artifact-publish	Runs the full design → validate → publish flow
"publish this report / plan / case / spec / brief"	Same, with the `kind` inferred
"put this in the gallery" · "make a Kapable artifact"	Same

What you can publish

Every artifact is a single self-contained HTML document (everything inline, nothing fetched at runtime), versioned immutably, and served under a strict Content-Security-Policy. Pick a kind:

kind	For
`report`	Status, delivery, and analysis reports
`plan`	Roadmaps, project and rollout plans
`spec`	Design specs and technical specifications
`case`	Business cases, proposals, narratives
`brief`	Short briefs, memos, session wraps

Under the hood

The skill publishes through the Kapable Artifacts API. You can call it directly too — with the @kapable/sdk or a plain request:

Method	Path	SDK (client.artifacts)
POST	/v1/artifacts	publish
GET	/v1/artifacts	list
GET	/v1/artifacts/{slug}	get
GET	/v1/artifacts/{slug}/html	html
POST	/v1/artifacts/{slug}/shares	share

import { KapableClient } from "@kapable/sdk";

const client = new KapableClient({
  baseUrl: "https://api.kapable.ai",
  apiKey: process.env.KAPABLE_ORG_KEY, // sk_org_… with write scope
});

const res = await client.artifacts.publish({
  slug: "q3-delivery-report",
  title: "Q3 — Delivery Report",
  kind: "report",
  html,                       // the validated, self-contained document
  summary: "What shipped, live-verified, in three unattended days.",
  favicon: "🧾",
});
console.log(res.url); // → https://{org}.kapable.ai/artifacts/q3-delivery-report

Once published, mint a revocable public link with client.artifacts.share(slug) — it serves the document, logged-out, at https://kapable.ai/a/{token} (noindex, honoring revocation and expiry).

The doctrine is the differentiator

Artifacts without the doctrine is a file server. The skill's whole point is that taste travels with the tool: it loads Kapable's design spec before writing a line of HTML, so a document published by an agent reads as designed, not slop. Do not skip that step.

More skills

This catalog grows as the platform does. Want a skill for another Kapable capability — or to publish one of your own? Reach us via the Forgejo or point your agent at kapable.ai/llms.txt.