artifacts
/artifacts
Use when seeing decides faster than reading — UI directions or mockups to choose between, a page to tune or click through, a design doc, review, proposal, or architecture walkthrough for them or their team to read — or when they ask for an artifact or artboard by name, or for a link to share one, self-hosted Anjian synchronization, or remote artifact comments. Inside brainstorming or anywhere else
- Author
- yusixian ↗
- Repository
- anjian ↗
- Licence
- MIT
- Last repository change
- 13.11.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 2
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when seeing decides faster than reading — UI directions or mockups to choose between, a page to tune or click through, a design doc, review, proposal, or architecture walkthrough for them or their team to read — or when they ask for an artifact or artboard by name, or for a link to share one, self-hosted Anjian synchronization, or remote artifact comments. Inside brainstorming or anywhere else
Original author description
Use when seeing decides faster than reading — UI directions or mockups to choose between, a page to tune or click through, a design doc, review, proposal, or architecture walkthrough for them or their team to read — or when they ask for an artifact or artboard by name, or for a link to share one, self-hosted Anjian synchronization, or remote artifact comments. Inside brainstorming or anywhere else
How it works
- Choose local or remote first
- Local workspace
- Pick the type
- Before writing
- Creative work
- Pick the artifact
- Start the local server and get the link
- Access from another device
- Directory
- After every change
SKILL.md preview
---
name: artifacts
description: Use when seeing decides faster than reading — UI directions or mockups to choose between, a page to tune or click through, a design doc, review, proposal, or architecture walkthrough for them or their team to read — or when they ask for an artifact or artboard by name, or for a link to share one, self-hosted Anjian synchronization, or remote artifact comments. Inside brainstorming or anywhere else
---
# Artifacts
Artifacts are pages your human partner opens in their browser while you
work: an artboard of mockups to choose from and comment on, a document to
read and comment on, or one HTML page to click and tune. You write files into the project; a local server shows each
artifact at its own link and updates it the moment a file changes. They look,
then comment in the browser or answer in the terminal. With a remote binding, files
reach the self-hosted server only after an explicit `push`.
## Choose local or remote first
Read the project's `AGENTS.md` for a configured CLI wrapper, project directory and
optional `ANJIAN_CLIENT_HOME`. Reuse that entry point and run `remote status --json`.
A successful status identifies the server and project; do not dump credential files.
Without a wrapper, use the CLI already discovered in the current environment
(check `command -v anjian` if its location is unknown). Read its `--help`, then
`skills get artifacts`; read each reference with `skills get artifacts --reference <name>`.
These commands return complete built-in documents without starting services or
authorizing a device. CLI output names the current executable; use that entry
point for the examples below. A source installation can instead use this skill's
`app/anjian.cjs`. Always pass the actual artifact project's `--project-dir`.
A missing binding is not evidence that a requested remote task should run locally:
read [remote.md](remote.md) to log in and link the target.
For a self-hosted URL, a remote binding, or remote comments, read [remote.md](remote.md)
before writing. Its `pull → edit → push → check → reply` flow takes precedence over
local server/streaming instructions below and in type references. Remote work needs
no SSH or local server. Use `start` only for an explicitly local preview.
## Local workspace
Use the Anjian workbench built from this repository. It has no official Cloud account,
cloud publishing, subscription, or automatic upstream package download. Self-hosted
device authorization is supported as described in `remote.md`.
Do not switch to a hosted artifacts tool to work around a missing local build.
If the launcher reports that its build is missing, run `pnpm install --frozen-lockfile`
and `pnpm build` in this repository's `artifacts/` directory, then retry the launcher.
Do not install `ryugi-artifacts` or an unverified `anjian` npm package.
## Pick the type
| What is being decided | Type | Read before writing |
| -------------------------------------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------ |
| Architecture, engineering design, a review, proposal or flow walkthrough | `document` | `document.md` |
| One surface or one dimension — a component, type scale, background, motion | `html` | `html.md`, `ui.md` for components |
| A business space — several screens, dimensions, states or questions at once | `artboard` | `artboard.md`; `artboard-prototype.md` for playable boards or parameters |
| Whether a built change matches what was approved, when they ask you to verify it | `artboard`, a verify group | `artboard.md` |
| Nothing to see | text | |
A control does not make it an artboard: one surface, however tunable, is
`html`. The artboard is for several dimensions at once; one group is one
dimension. "HTML" or "page" names the medium, not the type.
## Before writing
The type column is a gate, not a menu: open that doc first, in a command of
its own. Read alongside other files, a harness's output cap can cut it off
midway. `html` also reads
`ui.md` — its controls are `<anjian-…>`; artboard boards use plain HTML, CSS
and JavaScript, including their own event handlers. Verify against the doc —
ids, `anjian-change`, restored state — not just that it renders.
For board-level controls, `artboard-prototype.md` documents `data-anjian-tweaks`: a JSON
declaration creates a Parameters panel beside its board. Use it for a few
intentional levers; the board consumes typed values through CSS and JS.
## Creative work
Load the project's design system (tokens, components, type) before the first
frame; if it has none, say which type, scale and palette you are using. Use
real copy and data, never lorem ipsum.
For preview icons, read [icons.md](./icons.md). When implementing the
approved design, map its actions to the app's existing business icons;
the preview glyphs are visual references.
`html` is one surface: both themes when the product has them, and the states
the decision touches; a control tunes one dimension.
`artboard` is the space of a requirement: one group per question, its
variants differing in that one dimension; everything else stays still.
`document` is where architecture and engineering decisions are argued, with
diagrams and code — not a gallery of screens.
## Pick the artifact
Each artifact is `<project>/.anjian/artifacts/<type>/<id>/`. The id is
lowercase letters, digits and hyphens, named after the topic
(`arrow-tuner`, `header-nav`).
- Same topic: keep the same artifact and change it in place.
- New topic: a new id, and so a new link.
- Your human partner can override either.
## Start the local server and get the link
Use the discovered CLI or configured wrapper with `--json` for operations.
In a source installation, paths below are relative to this skill's directory:
resolve `app/` to its absolute path. When reading through `skills get`, the CLI
substitutes its executable into these examples; no source checkout is required.
A background start returns one JSON startup result; foreground mode stays running.
```bash
node app/anjian.cjs start --json --project-dir /path/to/project --artifact html/arrow-tuner
# {"type":"server-started","url":"http://localhost:27319/","port":27319,
# "root":"/path/to/project/.anjian/artifacts","link":"http://localhost:27319/html/<artifact-id>"}
```
- Give them `link` exactly as printed; `url` opens the artifact library.
- Run `start` before you write a new artifact's first file, so the page is
open while you write it.
- Run it again only right before a message that gives a link, with the
artifact you're about to mention; edits in between need no `start`. It
prints `"reused": true` while the server is up, and otherwise starts it on
the same port, so open tabs reconnect.
- One server serves every project on this machine and keeps running
between sessions. Every run registers your project with it.
- The browser opens when the first artifact is ready enough: for an artboard,
once its focus group is complete (or two boards when there are no groups),
even while later boards are still drawing. Pass `--no-open` only for
headless or scripted use. Still share the link; remote setups can't
auto-open. Read `artboard.md` for the streaming write order.
- Stop it with `node app/anjian.cjs stop --json`.
It stops the server for every project; the artifacts stay.
**Launching by harness.** The server must survive across turns.
- Claude Code: run the command as is; it backgrounds the server, on
Windows too.
- Codex: run it as is. With the server already running it returns at
once. Otherwise it detects `CODEX_CI` and stays in the foreground: give
it its own tool call with a yield of at least 5 seconds. When it starts a new server it does not return, so
anything chained after it with `;` or `&&` runs only once the server
stops.
- OMP (oh-my-pi): run it as is. OMP cuts output lines longer than 768
bytes, so pipe `comment list --json` and `check --json` through `jq .`.
Don't pipe `start`.
- Gemini CLI, Copilot CLI and others that reap detached processes: add
`--foreground` and start it with the harness's background-shell mechanism.
**Remote or containerized setups:** if the link is unreachable from their
browser, bind a non-loopback host and name the host they reach it by:
`--host 0.0.0.0 --url-host <reachable-host>`. A server bound that way refuses
requests without its key: its `link` carries `?key=`, so give it to them
complete.
## Access from another device
Anjian does not publish copies to an official cloud. A link works only while the
user-controlled server is running and reachable from that device. Do not promise
that a localhost link works on a phone or that a stopped server has a hosted copy.
For a user-authorized LAN setup, bind `--host 0.0.0.0` and use the machine's reachable
LAN address with `--url-host`. Keep the printed access key. The HTML/artboard preview
origin also needs to be reachable. For an HTTPS deployment, follow the repository's
self-hosting instructions and [remote.md](remote.md). Verify a successful push and
readback separately from merely opening the page; event output is not Agent wakeup.
Do not suggest Cloud login, `publish`, `get`, `config --auto-publish`, or subscription
upgrades: those commands are not part of Anjian. If a user supplies an old Ryugi Cloud
link, explain that importing it requires an exported local artifact; do not ask for
their official Cloud credentials.
## Directory
```
<project>/.anjian/artifacts/
artboard/<id>/ canvas.json + pages/ (you write); comments.json (server only)
document/<id>/ doc.xml + assets/ (you write); comments.json (server only)
html/<id>/ index.html + its files (you write)
.state/ the server writes; never edit
<type>/<id>/warnings.json warnings + pending; `check` prints it
artboard/<id>/layout.json computed geometry
```
- Keep each artifact self-contained: everything it uses lives inside its
own directory and is referenced relatively. Copy screenshots in; never
point at absolute paths.
- `.state/` keeps itself out of git. By default `.anjian/.gitignore` keeps
only documents in git; changing that is your human partner's call: leave
`.gitignore` alone.
## After every change
1. Write the files with your file-writing tool. For a remote binding, first pull
safely as `remote.md` describes; after editing, push successfully before `check`.
2. Run `check` after your last write. It waits until the server has checked
that write, then prints `warnings` (and `pending` for an artboard); no
sleep or `checkedAt` comparison is needed.
```bash
node app/anjian.cjs check --json --project-dir /path/to/project --artifact artboard/settings-nav
# {"type":"checked","artifact":"artboard/settings-nav","checkedAt":"…","warnings":[],"pending":[]}
```
Fix every warning. For `html` this includes `runtime: …` lines: errors
the page threw in their browser. They only count once `"ran": true`
shows the new version has loaded there; until then, an empty list
means "not run yet", not "no errors".
3. Tell them what changed, give the link, and ask for their answer in the
terminal. For a document, an `html` page or static boards, send that
message as soon as `check` is clean; screenshots or browser checks of
your own come after it, reported in the next message. Playable boards
follow `artboard.md`.
When the conversation moves on, leave the artifact as it is; it's the
record of what was explored.
Files in this package (2)
- SKILL.md 12 KB
- remote.md 7 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · yusixian/anjian | 95 | MIT |
| innei/ryugi | 100 | MIT |
| yusixian/anjian | 100 | MIT |
| allenai/asta-plugins | 100 | Apache-2.0 |
| innei/ryugi | 95 | MIT |
| yusixian/anjian | 95 | MIT |
| innei/ryugi | 95 | MIT |
| innei/ryugi | 90 | MIT |
| innei/ryugi | 90 | MIT |
Database snapshot: 13.11.2026 · package version 22b0ee788617 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100claude-design-brief
Generate paste-ready prompts for Claude Design (the artifact / design-canvas tool at claude.ai, NOT Claude Code) that are committed enough to skip its Q&A loop and start drawing on message one. Use when the user wants hi-fi mockups, an interactive prototype, multiple directions… - 90artifact-publish
Publish a visual or interactive deliverable as a Claude Code Artifact — a self-contained HTML/Markdown file rendered to a hosted, default-private claude.ai web page the user can share with a link — instead of leaving it as a local file. Use whenever a result reads better as a… - 90explore-design-directions
Develop and compare materially different UI/UX directions, choose the smallest decision-useful artifact, and present a recommendation for human selection. Use when a material design choice remains open; route explicit prototype, mockup, or design-lab work to prototype-design-directions. - 90artifact-use
Use when the user asks to publish, share, review, gate, get a link for, or check stats on agent output (self-contained HTML tools, dashboards, static folders, images, PDFs) through Artifact Use, or to read and resolve reviewer comments on a published artifact. Covers the hosted… - 90pf-design
Starts an Atelier project: scopes an idea, writes a brief, and creates a Claude Design artifact with one artboard per screen from the shared pf-design-system, then waits for approval. Use when the user says /pf-design, 'design a product', 'start a new product', 'new product… - 100writing-html-artifacts
Use when the user asks for HTML, a web page, an interactive tool, a dashboard or report as a page, or an offline single-file artifact, or when an answer would read better as a page and you want to offer one. Builds a styled self-contained page from a template, checks it, and…