kb-do

name: kb-do description: Create a Cline Kanban implementation ticket that picks the right Anthropic model (Sonnet 4.6 by default, escalate to Opus 4.7 for architecture/security/judgment-heavy work) and reasoning effort based on the task content. Works in any git-repo project (, , , anywhere) — auto-registers the project on first ticket if not already registered. Use when the user says "kb-do", "kanban do", "create a kanban ticket to do X", "make a kanban implementation task", or when adding any non-planning Cline Kanban ticket. Sonnet 4.6 or Opus 4.7 only. category: execution runtimes: [claude] pii_safe: true

Cline Kanban Do Skill

Create a Cline Kanban implementation ticket with model and reasoning effort chosen based on the work. Defaults to Sonnet 4.6 + medium reasoning; escalates to Opus 4.7 for architecture, security, ambiguous trade-offs, and judgment-heavy work.

Model choices: claude-sonnet-4-6 or claude-opus-4-7. No other models.

Project-agnostic. Works for any git repo: , , , hAIveMind — anywhere. Cline Kanban auto-registers a workspace the first time you pass its path to task create, so the same skill creates new projects implicitly. No web UI required — everything (project creation, ticket creation, linking, starting) is CLI-driven, which means it can be invoked from Discord/Jarvis, cron, or any automation that can shell out.

When to use

Trigger on any of: /kb-do, "kb-do", "kanban do", "create a kanban ticket to ", "make a kanban task", "add this to kanban", "have an agent do ", or any user request that ends with creating a Kanban ticket whose purpose is implementation (not planning — use /kb-plan for that).

Also invoke proactively when the user asks to add multiple Kanban tickets at once. Apply the model-selection logic to each one independently.

Inputs

Required: task description (free text)
Optional flags in args:
- --project <path> (defaults to current working directory)
- --title "<text>" (default: derive from first line of description)
- --model opus|sonnet (force a specific model, skip the heuristic)
- --effort low|medium|high|xhigh (force a specific reasoning effort)
- --auto-review commit|pr|move_to_trash (enables auto-review with this mode)
- --depends-on <task-id> (link this task as waiting on another)

Model selection heuristic

Apply these rules in order. First match wins.

Force Opus 4.7 (`claude-opus-4-7`) when ANY of:

Task involves schema design (new tables, columns with semantic meaning, multi-table refactors)
Task involves security-sensitive code (auth, crypto, secret handling, permission models)
Task is an audit / review / analysis producing recommendations (not just code)
Task requires defining semantics (what is a "unique X?", "valid Y?", "canonical Z?")
Task involves migration safety (live-DB changes, breaking API changes, data backfill semantics)
Task spans >5 files or touches >2 subsystems (high cross-context reasoning load)
Task description contains: "design", "architect", "decide", "evaluate", "trade-off", "should we", "audit", "review for"
Task is customer-facing copy that needs careful tone / accuracy (sales decks, status updates, public docs)

Reasoning effort for Opus: default to high. Escalate to xhigh when the task description suggests novel design (no existing pattern in codebase) or high-stakes correctness (security, financial, data loss possible).

Default to Sonnet 4.6 (`claude-sonnet-4-6`) for:

Implementing a documented plan (plan exists; agent follows it)
Adding tests (unit, integration, fixture-based) for existing code
Refactoring with clear before/after spec
Data migration scripts following a documented pattern
API integration work (calling a documented external API)
Adding columns/indexes that are mechanically specified
File renames, import path updates, dependency upgrades
Boilerplate generation, scaffolding, code formatting fixes

Reasoning effort for Sonnet:

low — pure mechanical (file moves, formatting, dep version bumps)
medium (default) — most implementation work
high — multi-step pipelines, debugging, integration work where things might go wrong
xhigh — rare for Sonnet; if it needs xhigh, consider escalating to Opus instead

Cheapest option = Sonnet at low effort

For trivial mechanical work, use claude-sonnet-4-6 at low reasoning effort. Do not consider any other model.

Procedure

Resolve project path. Use --project <path> if given, else pwd.
Apply the heuristic to pick model and effort. Print the choice and the reason in plain English ("→ Opus + xhigh because this defines schema semantics for a 960M-row table").
Compose the implementation prompt. Include:
- Goal (one sentence)
- Reference to any plan file or related ticket the agent should read first
- Inputs / data sources
- Deliverables (be concrete: file paths, schemas, scripts)
- Constraints (e.g., "additive schema only", "no plaintext secrets in artifacts", "use mcporter via ssh for external services")
- Definition of done
Create the task via Python subprocess (avoids shell-quoting pitfalls):
```
import subprocess
args = [
    '/usr/bin/node', '<LOCAL_PATH>/.local/bin/kanban', 'task', 'create',
    '--project-path', project,
    '--title', title,
    '--prompt', prompt,
    '--agent-id', 'claude',  # Claude Code agent — use this, not cline
]
if auto_review_mode:
    args += ['--auto-review-enabled', 'true', '--auto-review-mode', auto_review_mode]
r = subprocess.run(args, check=True, capture_output=True, text=True)
```
IMPORTANT: Use --agent-id claude, NOT --agent-id cline. The household's cline config has only an OpenAI-compatible local-MLX provider, no Anthropic provider — passing --cline-provider anthropic --cline-model claude-X causes "Incorrect API key" failures. Claude Code (the claude agent) uses its own auth and works.

Model recommendation is advisory: the chosen_model and effort from the heuristic are printed for the user to see ("→ Opus + xhigh because this defines schema semantics") but are NOT enforced via Kanban CLI flags. Claude Code uses whatever model is set at the user's session level (/model in Claude Code, or workspace defaults). Mention the recommendation in the prompt body if you want the agent to consider switching its session before starting.

If --depends-on <task-id> was provided, link the new task as waiting on that task:

'/usr/bin/node' '<LOCAL_PATH>/.local/bin/kanban' task link \
  --task-id <new-task-id> \
  --linked-task-id <depends-on-task-id> \
  --project-path <project>

Report back with:
- Task ID
- Chosen model + effort + one-sentence reason
- Whether to start it now or leave in backlog

Examples

Example 1: schema design → Opus

User: /kb-do design a credential_extracts table to normalize messages.text into structured rows

Heuristic match: "design" + "schema" + multi-table → Opus + xhigh
Title: "Design credential_extracts schema"

Example 2: mechanical column add → Sonnet low

User: /kb-do add canonical_name and last_seen_at columns to bots table, backfill from messages

Heuristic match: mechanical column add, documented → Sonnet + medium
Title: "Add canonical_name + last_seen_at to bots"

Example 3: API integration → Sonnet medium

User: /kb-do integrate binlist.net to enrich pan_first6 → issuing_bank in credential_extracts

Heuristic match: API integration, documented inputs → Sonnet + medium

Example 4: security audit → Opus

User: /kb-do audit our session token handling for vulnerabilities

Heuristic match: "audit" + security-sensitive → Opus + xhigh

Example 5: forced override

User: /kb-do --model sonnet --effort low rename references to old_table → new_table across the codebase

Override applied: Sonnet + low

Example 6: bug fix → Sonnet medium

User: /kb-do --project ~/Dev/<VOICE_RUNTIME> fix the TTS queue draining out of order in <VOICE_RUNTIME>-voice

Heuristic: bugfix in known component, single subsystem → Sonnet + medium
Title: "Fix TTS queue ordering"

Example 7: cross-cutting feature → Opus

User: /kb-do --project ~/Dev/<VOICE_RUNTIME> design a speaker-routing arbitration layer between the gateway, voice service, and Sonos worker

Heuristic: "design" + spans 3 subsystems → Opus + xhigh

Example 8: brand-new project (auto-registers in Cline Kanban)

User: /kb-do --project ~/Dev/new-thing scaffold a basic Flask app with one health endpoint

Cline Kanban auto-registers ~/Dev/new-thing on first task create (must be a git repo)
Heuristic: scaffolding → Sonnet + low

Driving from outside Claude Code

Cline Kanban is fully CLI-driven. Anything that can shell out to /usr/bin/node <LOCAL_PATH>/.local/bin/kanban (or remote-shell into and run it) can use this skill's logic. That means:

Discord Jarvis: a Discord command can take "/kb-do ..." text and run the same model-selection heuristic to fire off kanban task create. Cline Kanban becomes a visual launcher for tickets created from the phone.
Cron / scheduled agents: a cron job can create a recurring ticket on the right model.
CI / git hooks: post-merge hooks can create follow-up tickets.

The model strings (claude-opus-4-7, claude-sonnet-4-6) and reasoning levels (low|medium|high|xhigh) are stable Cline Kanban inputs — no special config needed beyond the workspace's existing Anthropic provider setup.

Anti-patterns

Do NOT default to Opus "to be safe" — that wastes inference cost on mechanical work.
Do NOT default to Sonnet for security/architecture work — false economy.
Do NOT pick a model without explaining why in your reply to the user. They should be able to override.
Do NOT pick any model other than claude-sonnet-4-6 or claude-opus-4-7. Sonnet at low effort is the cheapest option used here.

Companion skills

/kb-plan — when the work needs upfront design before implementation. Always uses Opus + plan mode.
/kanban — passcode and service management for the Kanban server itself.