tackline

Interactive code review as a panel discussion: an implementer agent defends decisions while a reviewer surfaces findings, with specialist reviewers added based on what the diff touches. Use when you want findings discussed in real time rather than a static report. Keywords: PR review, code review, meeting, panel review, interactive review, review discussion.

Use when starting a new project or adding Claude Code support to an existing one. Sets up CLAUDE.md, hooks, rules, and generates tailored agents. Keywords: bootstrap, scaffold, setup, new project, init, kickstart.

Use when you have a goal but don't know which skill fits. Routes to the right skill or pipeline. Keywords: do, run, auto, go, execute, start, help me.

Use when you need to research, analyze, compare, plan, or structure thinking and aren't sure which primitive to reach for. Chains operations (gather, distill, rank, filter, verify, etc.) automatically based on your goal. Prefer this over individual primitives for multi-step work.

Use when an agent's performance is uneven and you want systematic improvement. Runs diagnose -> challenge-gen -> challenge-run -> update learnings in a loop. Works with or without a team. Keywords: active-learn, training, adversarial, improve, agent, loop, capability, tuning, solo.

Use when starting a project, forming a team for long-horizon work, or upgrading from ad-hoc agent dispatch. Creates persistent roles with ownership and learnings that improve across sessions. Keywords: team, project, setup, roles, persistent, agents, staff, learning.

Use when learnings feel bloated, before sprints, after /retro, or when rules need a health check. Scores entries by relevance, archives stale ones, and detects knowledge gaps. Works on agent learnings or project rules. Keywords: curate, learnings, rules, optimize, relevance, prune, archive, gap, score, triage, audit.

Use after /curate or /retro when learnings have accumulated and you want to graduate durable patterns to project rules. Applies graduation criteria (3+ retro cycles, 21+ day stability, cross-agent applicability). Keywords: promote, rules, graduate, learnings, patterns, cross-agent, durable, governance.

Use at the end of a work session, after completing an epic, or when you want to capture what worked and what didn't. Evaluates velocity, quality, process, and blockers, then persists learnings.

Use when you have an assembled team and work ready to dispatch. Assigns tasks by ownership, injects accumulated learnings, and persists reflections from each agent. Keywords: dispatch, execute, work, plan, assign, run, do, build.

Use when a team exists but current status is unknown — backlog changed, context switch happened, or session just started. Syncs status, surfaces blockers, checks learning health. Keywords: status, sync, blockers, progress, team, check-in, reorient.

Use when you have a goal and want the team to plan it collaboratively — not explore (blossom) or brainstorm (meeting). Decomposes into sprint-ready tasks with member assignments. Keywords: plan, team, goal, collaborate, assign, tasks, kickoff, planning session.

Use after sprints, before major work phases, or on regular cadence. Runs /curate then /promote in sequence — keeps learnings sharp and graduates durable patterns to rules. Keywords: maintain, groom, lifecycle, learnings, rules, optimize, promote.

Use when you're unsure what to work on next. Reads git state, session history, and task tracker to recommend next actions. Works with just git, richer with more context. Keywords: advise, suggest, next, what now, recommend, orient.

Use when a goal is vague and you need to explore before planning. Runs spikes to discover what work exists, then produces a prioritized backlog. Keywords: explore, discover, spike, plan, epic, backlog, investigate.

Use after /diagnose-agent when you have a struggle profile and need training challenges. Generates edge-case and commit-replay challenges calibrated to weak areas. Keywords: challenge, training, improvement, active-learning, edge-case, replay, agent, weakness.

Use after /challenge-gen when challenges are ready to execute. Dispatches the agent on each challenge and evaluates result, trap detection, and calibration. Keywords: challenge, run, evaluate, active-learning, training, agent, performance, calibration.

Use when code is ready to ship and you want a structured deployment with readiness checks and rollback criteria. Supports direct, canary, blue-green, and rolling strategies. Keywords: deploy, ship, release, rollout, canary, blue-green, rollback, production.

Use when an agent's performance is uneven and you want to understand where it excels or struggles. Produces a struggle profile for /challenge-gen or /active-learn. Keywords: diagnose, profile, agent, weakness, strength, capability, assessment.

Use when a term is ambiguous or project-specific and needs a canonical definition. Also runs terminology audits to find stale or orphaned glossary entries. Keywords: terminology, glossary, definition, disambiguation, domain, terms, vocabulary, audit, stale.

Use after major skill edits or when definitions feel inconsistent. Detects shared patterns to factor out, missed cross-pollination, and structural divergence. Keywords: drift, convergence, divergence, cross-pollination, consistency, compare.

Use when you have a plan document and want autonomous implementation until it's done. Loops sprint/retro cycles, commits regularly, keeps going until complete or stopped. Keywords: drive, autopilot, autonomous, grind, build, implement, sustained, continuous.

Use when you need deep understanding of a focused area — not broad exploration. Recursively investigates, pruning paths that don't serve the goal. Keywords: explore, research, investigate, understand, deep-dive, discover.

Capture the orchestrator's mental model for a structured session transition. Use at end of long sessions, when /session-health recommends a fresh session, or before switching workstreams.

Use when you need multiple perspectives on a topic — brainstorming, requirements clarification, or pressure-testing an idea before committing. Runs an interactive agent panel discussion. Keywords: discuss, brainstorm, requirements, team, dialogue, perspectives, workshop.

Use before building high-stakes features — anything touching money, auth, data integrity, or security. Identifies failure modes and designs mitigations into the plan. Keywords: premortem, risk, failure, security, resilience, mitigation.

Run a session health diagnostic to assess context load, scope drift, and quality degradation. Use when responses feel degraded, before starting major new work in a long session, or when the user asks if you're still tracking well.

Use when you need a complete design before coding — multiple valid approaches, architectural alignment needed, or complex features. Builds a spec through progressive elaboration. Keywords: spec, frd, sdd, requirements, design, specification, document.

Use at session start or when you need to orient. Shows backlog, recent activity, team health, and last session summary in one view. Keywords: status, overview, dashboard, state, orientation.

Use when a feature crosses system boundaries and integration risk is high. Implements the thinnest end-to-end path first, then widens pass by pass — always working. Keywords: tracer, iterative, incremental, end-to-end, thin slice, vertical slice.

Use when you want to browse available skills or find the right pipeline for a workflow. Lists skills matching your goal with composition suggestions. Keywords: recommend, find skill, which skill, what skill, help, navigate, discover, pipeline.

Use when torn between architectural approaches or when you suspect hidden trade-offs. Three agents propose solutions optimized for different qualities, then tensions are synthesized. Keywords: consensus, architecture, trade-off, design, decision, compare.

Use when the backlog feels unwieldy — after a blossom run, before a sprint, or when you suspect duplicates or stale tasks. Deduplicates, fills gaps, and cleans up dependencies. Keywords: backlog, cleanup, dedup, triage, hygiene, review, organize.

Use when reviewing a skill/agent/rule and you need to understand why it looks the way it does. Shows edit history, churn, stability, and fix-after-feat patterns. Keywords: history, evolution, changes, timeline, churn, lifecycle.

Use after a human jam session to turn agreements into code. Converts shared artifacts into versioned event schemas, mocks, and validation config. Keywords: formalize, contracts, event schemas, boundaries, multi-human, event storming.

Use after parallel bounded-context implementation to verify contracts still hold. Checks compliance, runs cross-boundary tests, detects conflicts, and proposes merge order. Keywords: integrate, contracts, merge, cross-boundary, validation, multi-human, event storming.

Use when something works correctly but is too slow, too memory-heavy, or too resource-intensive. Measures baselines, implements fixes, iterates until a target is reached. Keywords: optimize, performance, profiling, bottleneck, latency, throughput, memory, benchmark.

Use after subagent implementation, before merging PRs, or when reviewing commit ranges. Structured review across correctness, security, style, architecture, and testing.

Use before a multi-human Event Storming session to prepare independent findings. Each participant's agents explore their domain and produce candidate events, aggregates, and assumptions. Keywords: event storming, domain events, prep, multi-human, exploration, DDD, aggregate, bounded context.

Use before writing code or when dispatching implementation tasks. Classifies what's known (codified/articulated/tacit) and picks the right testing approach — TDD when specs exist, exploratory when they don't. Keywords: test, TDD, BDD, testing, test-first, test-after, red-green, spec, acceptance criteria.