This skill produces one specific kind of artifact: a tabbed status page that represents a
project too big for one update — a software migration, a research effort, a launch, an org
initiative; anything with a set of parallel/dependent workstreams tracked over time. It
generates the HTML (one file, self-contained — the Artifact CSP blocks all external hosts,
so everything is inlined; the only <script> is the tab switcher) and publishes it with
the built-in Artifact tool to https://claude.ai/code/artifact/<uuid>. The page is
default-private; the viewer gives the owner a version picker and lets them share it with
teammates. (The general "render any HTML/Markdown to a web page" capability is the built-in
Artifact tool; this is the project-tracker structure on top — defining what an artifact
is belongs to that tool, not here.)
The SWE specifics for PR-driven projects are in swe.md, kept out of this file so the
project-artifact structure stays domain-neutral.
Resolve the artifact config, then locate the project. Each project gets a directory
at ${CLAUDE_PLUGIN_DATA}/artifacts/<slug>/ holding config.md (see "The artifact
config" below) and page.html (the current render); listing artifacts/ is the
registry of this skill's artifacts on this machine. If the
user names a project,
load that slug; if exactly one config matches the session (its repo is the cwd, or its
project came up in conversation), use it; a config that exists means this is a
refresh — follow "Refreshing an artifact" below. No config means a first build:
gather from scratch and write the config after the first publish — but if the user says
the project already has a published artifact (made on another machine or in a lost
session), get that URL and record it instead of minting a new one.
Then collect the source material: the goal, the set of workstreams (PRs, milestones,
sub-projects, tasks), owners, dates, and any sibling docs (design doc, plan, spec).
Pull whatever the domain gives you cheaply — always live, never from memory or earlier
turns — for software that's gh pr list / git log / gh pr view (see swe.md); for
other domains it's the project doc, a tracker, a spreadsheet, your own notes. If the
source is itself an existing claude.ai/code/artifact/... page to reshape, fetch it —
see "Reading an existing artifact page" below. Don't ask the user to paste content or hand you a local file
as a substitute for fetching it yourself.
Pick the tabs from the catalog below — only the ones with real content.
Overview and the Workstreams sequence are the spine and are essentially always
there; Attention, Background, Plan, Risks & open questions, and
Decisions/FAQ each earn a tab only when there's something substantive to put in it
(a simple, self-explanatory project may have just Overview + Workstreams; a big one ~6–8). Never
ship an empty tab. If this is a software project, swe.md notes the extra tabs a
rigorous one tends to want — none of them mandatory.
Generate the HTML from template.html in this skill directory (same folder as this
SKILL.md): it already has the house style (light/dark via prefers-color-scheme, CSS
variables), the header, the status banner, the next-steps strip, both tab mechanisms
(JS-toggled panes as the default; pure-CSS radio tabs as a no-JS alternative), the
status-pill classes, and a stub <section> per catalog tab with fill-in comments. Fill the stubs, delete unused
tabs, keep it one file. Set a concise <title> — the Artifact tool uses it as the
page's name in the browser tab and the claude.ai gallery, and falls back to the file
basename without one; keep it stable across redeploys. Write the file to the config's
html path — default ${CLAUDE_PLUGIN_DATA}/artifacts/<slug>/page.html, next to the
config (not /tmp; not inside the user's repo unless they ask — if they do, use
<repo>/.claude/project-artifact/<slug>.html and record it as the config's html path):
a stable path means the Artifact tool redeploys to the same URL within a session, and
the previous render stays around for the next refresh's delta. Embed the state
block (see "Refreshing an artifact") so the next run can compute what changed.
Review the output for cut-off text and overflow. Before publishing, re-read the
file and check that nothing gets clipped or truncated: fixed-width table columns
squeezing their contents, long unbroken strings (URLs, PR/branch names, IDs) overflowing
their container, anything sitting behind overflow:hidden or white-space:nowrap. The
viewport is unknown (could be a phone): wide content — tables, diagrams, code blocks —
must scroll inside its own overflow-x:auto container, never the page body. After
publishing, open the page and eyeball it — if anything is clipped, wrap or shorten it
(word-break, a smaller font, a shorter label) and redeploy.
Publish with the Artifact tool. Call Artifact with file_path = the HTML,
favicon = one or two emoji that fit the project (keep the same emoji on every
redeploy — viewers find their tab by it), label = a short version tag (e.g.
"phase 1 cut" or the date — shows in the version picker), and — on a refresh — url =
the config's recorded artifact URL so the redeploy lands on the same address. The tool
returns the https://claude.ai/code/artifact/<uuid> URL; the slug is server-minted,
not chosen.
Share it. First publish is private to the user — teammates can't open it (they get a 404) until the user shares it. Tell the user to open the artifact on claude.ai and share it with their teammates from the viewer; redeploys preserve the sharing setting.
(Optional) Register on a hub. If the user keeps a project hub or index page, append the artifact URL there per that hub's instructions. The slug is opaque, so a hub or bookmark is how teammates find it. Skip if there's no hub.
Write the config and report. On a first publish, write
${CLAUDE_PLUGIN_DATA}/artifacts/<slug>/config.md now — recording the minted URL, favicon,
title, and html path is what makes every later "refresh the artifact" land on the same
address from any session. Then report the URL, the favicon you picked, and which tabs
you filled. The page is a living artifact — it drifts the moment anything changes;
updates follow "Refreshing an artifact" below. If a publish reports a conflict (another
session published a newer version), WebFetch the URL to see the current content,
reconcile, then publish again.
A small markdown file at ${CLAUDE_PLUGIN_DATA}/artifacts/<slug>/config.md, in the
plugin's persistent data directory (exposed as CLAUDE_PLUGIN_DATA; it survives plugin
updates and is only removed on uninstall). It is machine-local: a user who wants a config
to follow them across machines can keep it in their dotfiles and symlink or copy it in —
the format is the same. Sections, all short:
url (written after the first publish; every later publish passes it),
favicon, title, html path (default ${CLAUDE_PLUGIN_DATA}/artifacts/<slug>/page.html).gh query parameters
(author, head-branch prefix), the tracker project (Linear/Asana/issues), key docs and
channels, and how workstreams map onto those sources (for software see swe.md).
Date-tag entries that were verified by a human ("verified 2026-06-17") and re-verify
stale ones before relying on them.When no config exists, never block the first build on filling one in — gather, build, publish, then write the config in step 8.
"Refresh the artifact", "update the status page", and a repeat /project-artifact <project>
all mean: re-gather, re-render, redeploy the same URL, and tell the user only what
changed.
<script type="application/json" id="artifact-state"> carrying {"as_of": "<UTC>", "workstreams": [{"id", "status", "owner", ...}]} (software: one entry per PR, with the field list defined in swe.md —
don't improvise a different shape). It is invisible on the page and exists only so the
next run can diff against it.as_of
also anchors the gather window ("what changed since"). If the local file is missing but
the config has a url (new machine, reinstall), WebFetch the artifact URL to recover
the current page and its state block first. No previous render anywhere means first
render — say so instead of inventing a delta.url.< → <, & → &), and never let a literal </ reach the
artifact-state JSON — write < as \u003c inside JSON strings — so a branch name or
PR title containing </script> can't terminate the block and run as script on the
published page.claude.ai/code/artifact/... — use WebFetch with the URL; it returns the page HTML.
This works for artifacts the user owns or that have been shared with them — anything else
404s (unauthorized and nonexistent are indistinguishable by design). If it 404s, ask the
owner to share it, or work from the project's underlying source (repo/PRs/design doc)
instead of the rendered page.
Use only the tabs with real content; order matters (readers go top to bottom).
| Tab | Include when | Goes in it |
|---|---|---|
| Overview | always | What this project is, why it exists, who's involved. The motivation can be light — a single line, or skipped — when the goal is self-evident; don't pad an obvious "why" into paragraphs. Success criteria — each with a check (how you'd know it's met) and a status; group them when they span distinct concerns (e.g. product vs security vs perf, or must-have vs nice-to-have — sub-tables or sub-headings), one flat table when there's only a handful. A short Out of scope list bounds the reader's worry. |
| Workstreams (a.k.a. Sequence / Milestones) | always | The headline table — one row per workstream: id · what · owner · status (+ dates), status pills — plus the current state at a glance (what's done, what's in flight, what's blocked; this is not a separate tab). If the order doesn't make dependencies obvious, add an "after <id>" note in the row — don't draw a diagram. For each workstream worth detail, a block: what's done, how it was verified/validated, links. (Software: this is the PR sequence — see swe.md for the X.Y numbering, which already encodes the dependencies, and the per-PR block. A very high-churn project can split a separate changelog tab.) |
| Attention (a.k.a. Waiting on) | the artifact is refreshed regularly and drives action, not just orientation | Three short lists, action first. Waiting on the owner: numbered, priority order, each item the exact action (a paste-ready message or a one-word decision) plus one sentence on what it unblocks. Automatic once those land: the chain that needs no action (auto-merge cascades, deploys, tracker auto-close). Waiting on others: who · what · which item (linked) · where to nudge. Skip it on a one-shot overview page. (The next-steps strip under the banner always carries the top of these — see Conventions.) |
| Background / Concepts | the project isn't self-explanatory | The context a newcomer needs before the rest makes sense — prior work, the problem, the key ideas/vocabulary. The "what a colleague would tell you over coffee" version; link forward to a deep-dive tab if there is one. Skip it when the project is simple/obvious. |
| Plan / Approach | the how is non-obvious | The strategy — the phases, the sequencing rationale, why this shape and not another. Skip it when the plan is just "do the workstreams in order". |
| Risks & open questions | there are real ones | Risk register (risk · likelihood/impact · mitigation · owner) plus the unresolved questions the project hasn't answered yet. Include the ones the team already knows about — the honest caveats build trust. A low-risk project with no open questions can drop this. |
| Decisions / FAQ | people keep asking | The questions people actually ask, and the decisions made + rationale. "Why this approach?", "Why not X?", "What does done look like?" |
.next strip), above the tabs
so it's visible whichever tab is open. 1–3 items, most important first, each
who → the exact action → what it unblocks — the concrete moves that take the project
from its current state to the next one, not a restatement of the remaining workstreams.
The strip is a collapsible <details open>: always ship it open, and keep the item
count in its <summary> so a reader who collapses it still sees how much is pending
(when the body is the one-line fallback, the summary count reads "none pending").
Nothing pending? Keep the strip and say so in one line ("No action needed — …", naming
whatever ambient work remains) rather than deleting it — "there is no next step" is
itself the answer the reader came for. The strip stands on its own: it appears whether
or not the page has an Attention tab; when that tab is present it holds the full
waiting-on lists and the strip is their top. When no human owner is recorded, name
whatever actor exists (the PR's author or reviewers, the owning team) rather than
inventing one.done / in progress / next / blocked /
⚠ caveat. Define the classes in CSS once (template has them).over, work, att,
… ids) — the next refresh edits the previous render in place and keys off them.data: URI; one small <script> for
tabs is fine. System font stacks only.<svg> in the page,
not an external image, a screenshot, or an ASCII-art block. SVG keeps the page
self-contained, scales crisply, wraps with the layout, and can use currentColor / the
CSS variables so it tracks light/dark. Keep it simple and also state the same fact in
text — a diagram supplements the prose, it isn't the only place a fact lives. This is
not a license to diagram the workstream dependencies: the ordering (and the X.Y
numbering in swe.md) already encodes those — skip the DAG.Domain-specific guidance lives in sibling files (same directory as this SKILL.md), so the core idea above stays neutral:
swe.md — software projects whose workstreams are PRs: the gh/git workflow to
pull PR state, the X.Y PR-numbering convention (the one thing genuinely different
from this base template — it encodes which PRs block which, so you don't draw a DAG), a
per-PR detail block, and a short note on the extra tabs/rigor a thorough software project
tends to want (architecture deep-dive, review findings, rollout/rollback, must-have vs
nice-to-have requirements) — all of that optional, the skill user's call.Add another sibling (research.md, launch.md, …) when a domain shows a repeated shape
worth capturing — but only once you've actually built two or three of that kind.
(All in the same directory as this SKILL.md.)
template.html — domain-neutral skeleton: CSS, header, status banner, next-steps
strip, both tab mechanisms, pill classes, one stub <section> per catalog tab with
fill-in comments.swe.md — the software-project specialization (read it when the workstreams are PRs).