Kanban Workflow

The board has five stages. A card moves left to right as the work matures:

Each card has a type (feature, chore, bug), a priority (critical, high, medium, low), and a sequential card number like #0001 that is assigned on creation and never reused. Archiving does not delete a card: archived cards move to a cold-storage file next to kanban.json and can be restored at any time.

• Checklist: task items with done state, shown as a progress count on the card face.
• Problems: tracked issues with a severity (minor, major, critical). A problem can be resolved in place or promoted into its own card, with severity mapped to priority.
• Areas and tags: areas come from the project's context-priming setup; tags are freeform labels. Both render as chips on the card.
• Agent notes: a shared note thread with per-agent attribution, so Claude, Codex, and Gemini contributions stay distinguishable. Long threads can be summarized: the oldest notes collapse into a single summary note, and summaries can themselves be summarized later.
• Status line: a short progress label with a timestamp, rendered as an LED-style panel on the card (see below).
• Document refs: attached design, feature, and test documents, HTML attachments, and questionnaires (see below).

Clicking a card opens a modal with tabs: Details, Design, Feature, Test, HTML, Questionnaires, Notes, Checklist, and Terminal. The HTML and Questionnaires tabs only appear when the card has those attachments.

The Terminal tab is the card's workspace: it holds live AI sessions scoped to that card, and a card can run Claude, Codex, and Gemini sessions at the same time, each with its own status dot. Sessions survive moves between stages.

Cards link to documents in five categories: design, feature, test, HTML, and questionnaires. All five are lists, so a card can hold multiple documents per category. On the CLI, each ref flag appends; passing an empty string clears a category, and --unlink-ref <path> removes a single document without deleting the file.

sly-kanban update <card-id> --design-ref "documentation/designs/my_design.md"
sly-kanban update <card-id> --test-ref "documentation/tests/my_test_plan.md"
sly-kanban update <card-id> --unlink-ref "documentation/designs/old_design.md"

• Design, feature, and test docs render inline in their tabs. Multiple refs show an index list with per-entry unlink.
• HTML attachments are self-contained HTML files (diagrams, interactive explainers) rendered in a sandboxed viewer: network requests are blocked, and a Print button opens a clean print view.
• Questionnaires are structured Q&A forms that agents attach when they have several related questions. You answer in the modal with real input controls (choices, scales, yes/no, free text), answers autosave, and Submit delivers a formatted Q&A block straight into the card's terminal session. All questions are optional.

Sly Actions are one-click prompt buttons on the card terminal. They are stage-aware: a backlog card offers different actions than a card in testing, so the next step is always one click away. The core sequence:

1. Onboard: comes before design. Takes a rough, one-line card and turns it into a structured one: a clear title, a structured description, and the right areas and priority.
2. Design: gathers requirements and produces a design document, attached to the card as a design ref. A deeper variant runs parallel analysis for larger pieces of work.
3. Implement: moves the card to implementation, adds a checklist, executes the plan, and leaves a summary note.
4. Review and challenge: in testing, review actions check the result, and challenge actions send the work to a different AI provider for an adversarial second opinion. Findings come back as agree, disagree, or discuss, and nothing changes without your approval.

Actions are markdown files with a prompt body, so you can edit the built-in ones or add your own, and scope them to stages, card types, or projects.

Agents drive the board through the sly-kanban CLI, and you can too. Board data lives in kanban.json inside the project's documentation folder, and the web UI, CLI, and automations all edit it safely at the same time.

sly-kanban search --stage backlog
sly-kanban show <card-id>
sly-kanban create --title "Title" --description "..." --type feature --stage backlog
sly-kanban move <card-id> design
sly-kanban checklist <card-id> add "Task to complete"
sly-kanban problem <card-id> add "Broken on mobile" --severity major
sly-kanban notes <card-id> add "Implemented the parser" --agent claude

Every command that takes a card id also accepts the exact card title, so sly-kanban show "My Card Title" works.

The status line is a short, timestamped label on the card face that answers "where is this at?" without opening the modal. There are two kinds:

• Manual: set explicitly with sly-kanban status <card-id> "Blocked: waiting on API key". A manual status is never overwritten by automatic updates.
• Auto: written automatically by card activity, such as "Problem reported", "Design doc attached", or "Checklist: 3/6". Auto statuses are tiered, so a checklist tick never overwrites an open problem report.

Moving a card to a different stage clears its status, since the old label no longer applies. To carry a fresh status across the move, use sly-kanban move <card-id> testing --status "Ready: needs review".

One card's session can send a prompt into another card's session with sly-kanban prompt. The prompt arrives prefixed with the target card's context (title, stage, type, description), so the receiving AI knows exactly which card it is working. You can fire and forget, or pass --wait to block for a reply. This is what powers the challenge actions: sending a design to a different provider and collecting its response.

• Skills: the workflows behind the actions, and how to customize them.
• Automations: scheduled cards that run prompts on a cron schedule.
• Multi-provider setup: run Claude, Codex, and Gemini side by side on the same board.