ck

Code Katz personas and workflows for Claude Code. One plugin: the product-definition pipeline from an idea to a designed feature, a three-lens decision panel, and the full persona roster, a complete cross-domain team, as subagents and switch commands on three model tiers.

Every document ck writes goes into the repository you opened Claude Code in, under docs/ (or ROADMAP.md and brand/), and is committed with your product. Every document has a contract, so it has the same shape every time, on every project.

Status

Phase one, first release in progress. What runs today:

Command	What it does	State
/ck:next	Shows the whole pipeline as a table (each step in order, what it does, the document it writes, and where your project stands), then says what to run next in one sentence	Built
/ck:brief <idea>	Toni runs a short market pass, River writes docs/brief.md (from your sentence, or from docs/opportunity.md), a checker validates it; you review on a page you can comment on	Built; drilled 2026-10-04 on a real project
/ck:plan [work]	Quinn lays the work out as a staged plan: phases, then stages, one job and one owner per row, each with its state. With nothing after it, the whole release from the roadmap (docs/build-plan.md); with a piece of work after it, that one item (docs/plan/). You review it on a page you can comment on	Built; not yet run on a real project
/ck:start [stage]	Opens the plan's sessions and keeps its board. For a stage it offers a card that starts a session for that one job, named from the row, such as [A31-P2-S1] [Akira Fable] Make the creature tables; with nothing after it, it updates the State column from the sessions and their pull requests and offers every row that could start now. With fix <stage> <what is wrong> it offers a card for a session that fixes one fault in a stage that is done, named such as [A31-P1-S5 fix] [Akira Fable] Mend the scan's natural 1; the stage stays done. Every new session checks its own model before it works. You click each card	Built; not yet run on a real project
/ck:do <task>	The quick path, all in the chat: a plan of a few lines (who does what and the rough cost), you say go, the right personas work in the background on their own tiers, a mockup comes back as a link when you ask for one first, and a build waits on its own branch until you say merge. No documents and no proofs	Built; not yet run on a real task. Its cost line is an estimate
/ck:panel <question>	River, Toni, and Kai argue one question on three different models; a memo shows where they disagree	Built
/ck:prd [--panel]	River drafts docs/PRD.md from the brief, a checker validates, River adds a premortem; with --panel, three specialists on three models challenge it first and River rewrites; you review on a page you can comment on	Built; drilled 2026-10-05 on a real project
/ck:team	Who is on this product, who owns what, which seat is missing: docs/TEAM.md; you review on a page you can comment on	Built; drilled 2026-10-05 on a real project
/ck:architecture [--panel]	Akira recommends an architecture from the PRD and roadmap and adds a premortem; with --panel, Morgan, Alex, and Jordan challenge it first on three models; you review on a page you can comment on	Built; drilled 2026-10-05 on a real project
/ck:opportunity <idea>	River frames the idea, Toni, Akira, and a domain seat write sourced sections, River assembles docs/opportunity.md; you review on a page you can comment on	Built; drilled 2026-10-01
/ck:market-research [focus]	Toni plans the questions, researchers answer them from the web in parallel, a cross-check marks what is unsourced or contradictory, Toni writes docs/market-research.md	Built; drilled 2026-10-01
/ck:roadmap	River prioritizes the PRD's requirements into three tiers, Quinn sequences them and writes ROADMAP.md in the roadmap skill's format, with a dated revision entry; you review on a page you can comment on	Built; drilled 2026-10-05 on a real project
/ck:brand-guide	Three rounds: Toni positions, Iris designs four to six brand directions, Kai skins a screen in each, you pick from a gallery; the picks are worked up in full as a second gallery; then the brand direction record, docs/brand-guide.md, and the assets under brand/final/	Built; drilled 2026-10-01
/ck:design <feature>	River pulls the feature from the PRD, Kai draws three labeled variants of its screens with their empty, loading, and error states, you pick one from a gallery, then Kai finishes it at full fidelity with docs/design/<feature>/spec.md and Robin adds the acceptance checks	Built; drilled 2026-10-01
/ck:<persona>	Switch this session to a persona, for example /ck:river	Built, every persona
ck:<persona>	Delegate one task to a persona on its own model tier, for example the ck:river subagent	Built, every persona

The specification is the phase-one PRD in code-katz/.github, plans/2026-09-05-ck-plugin-prd-phase-1.md.

Prerequisites

1. Uninstall the old team tool (claude-team-cli). Its persona commands, subagents, and session hook collide with ck's. Steps are below. ck warns at the start of every session while any of it remains.
2. Claude Code 2.1.221 or later, signed in with /login to a Claude account on a paid plan. Dynamic workflows must be available: on a Pro plan, turn them on in /config; an organization can disable them.
3. For proofs with comments: the same version, and a Claude account that can publish artifacts. A page's owner can comment on it on a Max plan; sharing a page with other people needs a Team or Enterprise plan.
4. For development only: Bash 4 or newer, python3, and Node 20 or newer, for scripts/generate.sh and tests/run.sh. The plugin itself needs none of them at run time.

Uninstalling the old team tool

Remove each of these if present:

rm -f ~/.local/bin/claude-team
rm -rf ~/.claude/team

Then remove the persona files it installed under ~/.claude/commands/ and ~/.claude/agents/ (one <persona>.md per persona: river.md, akira.md, and so on), the block it wrote between its markers in ~/.claude/CLAUDE.md, and its SessionStart entry in ~/.claude/settings.json. Start a new session; the warning line is gone when everything is removed.

Install

From the Code Katz marketplace:

/plugin marketplace add code-katz/claude-plugins
/plugin install ck@code-katz

For development, load the checkout directly:

claude --plugin-dir /path/to/ck

After editing a workflow in a running session, run /reload-skills.

How a run works

1. You type a command. If it needs a document you do not have yet, it says which command writes it, and stops.
2. The work runs in the background as a workflow; /workflows shows every agent, model, and token count if you want them. The command itself never prints them.
3. The document appears in your repository. Commands with a review step publish it as a proof, a page you can comment on, with the steps in the proof's banner. Comment on the page without sending comments to Claude (a comment sent to Claude wakes a cloud session that cannot see your files), then say "done" in your Claude Code session; Claude proposes a change for each comment, applies the ones you approve, republishes the same proof, and tells you what changed.
4. Each pipeline command closes with the pipeline table: each step in order, what it does, the document it writes, and where your project stands, with the one thing to run next under it. /ck:next shows the same table at any time.

Type each command; do not paste it. A pasted command reaches Claude as text, and the skills that own the run record and the proof run only when typed, so the most Claude can do is start the workflow underneath: the document is written, with no run record and no proof. Typing the command afterwards takes the finished document to its review.

Where things go, inside your repository:

Document	Path
Opportunity analysis	docs/opportunity.md
Market research	docs/market-research.md
Brief	docs/brief.md
PRD	docs/PRD.md
Team	docs/TEAM.md
Roadmap	ROADMAP.md
Architecture	docs/ARCHITECTURE.md
Brand guide and assets	docs/brand-guide.md, brand/
Design gallery and spec	docs/design/<feature>/
Staged build plan	docs/build-plan.md
Decision memos	docs/decisions/

A staged plan for one piece of work, written by /ck:plan <work>, goes under docs/plan/.

.ck/runs/ is a cache for in-progress runs. Nothing depends on it, and ck excludes it from git locally without touching your .gitignore.

Models

Three tiers, set once in tiers.conf:

Tier	Model	Personas
Judgment	Fable 5.1	River, Akira, Morgan, Sage, Jordan, Reiner
Craft	Opus 5	Toni, Kai, Iris, Quinn, Casey, Cornelius, Ernie, Rez, Tracy, Travolta, Noon
Execution	Sonnet 5	Sasha, Alex, Robin, Piper

Validators run on Haiku 4.5. The panel puts its three lenses on three different models: River on Fable 5.1, Toni on Opus 5, Kai moved down to Sonnet 5. A switch command (/ck:river) runs on your session's model; delegation (ck:river) runs on the tier.

Development

Personas live in profiles/<name>.md and tiers.conf. Everything else about a persona is generated:

bash scripts/generate.sh     # agents/, skills/<persona>/, profiles/ROSTER.md
bash tests/run.sh            # the static checks, and every workflow script run with stub agents

Edit the profile, never the generated file; the generator refuses to overwrite uncommitted hand edits to generated files unless you pass --force. Every release bumps version in .claude-plugin/plugin.json, or nobody receives it.

The suite also lints the Python in scripts/ and tests/ with Ruff, to the rules in ruff.toml, when Ruff is installed (pipx install ruff). Without it the lint is skipped, and the suite says so. In CI, where the CI variable is set, a missing Ruff fails the suite: nobody reads a note there.

A stage of a staged plan can have its checks written before its work. They are one Bash file, named for the stage, under tests/pending/: the suite runs it, lists each check that fails as waiting, and still passes. The stage is done when every check in its file passes and the file has moved to tests/checks/, where its checks count like any other. A file left under tests/pending/ with every check passing fails the suite. A stage may tighten the checks in its file, and never loosens one.

Layout:

.claude-plugin/plugin.json   the manifest; name "ck" sets the /ck: prefix
profiles/                    persona source of truth, plus the generated ROSTER.md
tiers.conf                   persona -> model
ruff.toml                    lint rules for the Python in scripts/ and tests/
agents/                      generated subagents, ck:<name>
skills/<persona>/            generated switch commands, /ck:<name>
skills/opportunity, prd, architecture, brand-guide, design, next, proof-loop
skills/*-artifact/           the ten document contracts
workflows/                   panel, brief, draft (PRD and architecture), team, opportunity-draft, market-research, roadmap, brand, design-round
hooks/hooks.json             usage log on SubagentStart; old-tool check on SessionStart
scripts/                     generate.sh, render-proof.py, render-gallery.py, usage-log.sh, check-prereqs.sh
tests/                       run.sh, workflows.mjs (the workflow scripts run with stub agents), two fixture projects, the gallery fixtures, and the drill logs
tests/checks/, pending/      one file of checks for each stage of a staged plan: counted, and waiting for the stage's work

License

MIT. See LICENSE.