ClaudeKit is not a standalone app or a new IDE. It is an advanced Framework integrated directly into your native Claude Code configuration (.claude) on your machine, transforming your terminal chat into a professional task automation system.
Background scripts that run automatically. They initialize configs and project rules so you don't have to copy-paste them manually.
Specialized capability packages with prompts, references, and scripts. The primary execution unit when you type /ck:* commands.
Specialized models (Planner, Tester, Reviewer) with internal prompts and tools, focusing on a single task domain.
Pipelines of Hooks, Skills and Agents running sequentially from your command input to handle complex workflows end-to-end.
Let's see how Hooks, Skills, Agents and Workflows coordinate a real command. Pick a workflow below and press Play to explore the internal mechanism.
steps •
No combos for this kit
VividKit is finalizing the detailed guide for Marketing Kit.
Quick Ref / Brainstorm command
Before /ck:plan
Use it when the right approach is still unclear. Scout first, lock exact requirements, debate trade-offs, then write a report and hand off to /ck:plan.
Scout
Exact reqs
Debate
Report path
Scout first
Summarize 3-6 findings before Discovery.
Report first
The plan handoff receives the brainstorm report path.
No Task-spawn
planner/docs-manager are inline consultation.
Four lanes: scout, clarify, evaluate, then close with report/handoff.
Scout
Context before questions
Clarify
Lock the 5 exact fields
Evaluate
Trade-offs and brutal honesty
Handoff
Report, then plan/end
Use different prompts for a new brainstorm, a same-session plan handoff, and a fresh-session plan.
/ck:brainstorm Choose the best auth approach for our current SaaS app Use when: The direction is unclear and needs repo scouting plus trade-off debate first.
Expected: Writes the report at plans/reports/brainstorm-260524-1908-auth-approach.md.
/ck:plan Create an implementation plan for the auth approach we selected in brainstorm, using the report just created as context Use when: You are still inside the brainstorm session and the agent just wrote the report.
Expected: Plan uses current context plus the report path handed off by brainstorm.
/ck:plan plans/reports/brainstorm-260524-1908-auth-approach.md Use when: After a long brainstorm, start a fresh session to avoid context bloat.
Expected: Mention the file path so plan reads the correct brainstorm artifact.
Inside the brainstorm session, offer only after proposal approval, no open questions, and a written report. If starting a fresh session, make sure the brainstorm artifact exists and pass its file path to plan.
/ck:plan --tdd Recommend when: Refactor, critical logic, or strong existing test contracts.
Result: Same session: use the report context just created. Fresh session: include the artifact path.
/ck:plan Recommend when: Standard new feature or moderate change.
Result: Phase-by-phase implementation plan from the brainstorm report.
End session Recommend when: Plan later or hand off elsewhere.
Result: Stop after report/journal.
Markdown Summary Report
Brainstorm ends with one Markdown file. This file is the primary context for the /ck:plan handoff.
Concrete path
plans/reports/brainstorm-YYMMDD-HHMM-slug.md plans/reports/brainstorm-260524-1908-auth-approach.md Report Contents
This is the outline inside the report file, not separate artifacts.
Rule: Anti-Rationalization
Common-sounding excuses the workflow blocks before planning or coding.
Thought
This is too simple to need a design
Reality
Simple work wastes time when assumptions stay implicit.
Thought
I already know the solution
Reality
Then writing it down is quick. The written design is the alignment checkpoint.
Thought
The user wants action, not talk
Reality
Bad action wastes more time than a short planning loop.
Thought
Let me explore the code first
Reality
Brainstorming decides how to explore. Follow the process first.
Thought
I'll just prototype quickly
Reality
Prototypes become production code. Design first.
Quick Ref / Command
Engineer Kit
Pre-implementation impact prediction: five personas debate a proposal, then optional chain modes refine tradeoffs or missing constraints.
Input
Context
Personas
Agreements
No implementation
Architecture risk
Independent persona analysis first
Security risk
STOP blocks work
Performance impact
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
--files <glob> Read affected files before analysis
--chain reason Use critics and blind judge for subjective tradeoffs after CAUTION
--chain probe Generate constraint probes when CAUTION/STOP comes from missing information
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:predict "Move notification delivery from polling to WebSockets" /ck:predict "Replace REST user endpoints with GraphQL" --files src/api/**/*.ts /ck:predict "Move auth sessions to Redis" --chain reason /ck:predict "Use WebSockets for live notifications" --chain probe Prediction Report
Pattern
verdict + agreements + conflicts + risks + recommendations + optional chain appendix The report gives GO/CAUTION/STOP plus risk rows that can become scenario tests, plan constraints, or cook acceptance gates.
Quick Ref / Planning command
After brainstorm / when scope is clear
Use it when the brief is clear enough to split into phases, validation gates, and a clean /ck:cook handoff.
handoff
/ck:cook {absolute-path}
Clear brief
Plan phases
Validate / red-team
/ck:cook
No implementation
Only creates plan and phase files.
Clear handoff
Ends with validate, red-team, cook, or stop.
Four lanes: orient scope, research, stress test, then hand off.
Orient
Set context before planning
Research
Collect enough evidence
Stress Test
Find weak points early
Handoff
Make the plan executable
Start with auto. Escalate only when scope or risk demands it.
--auto Auto-detect --fast Fast Sample prompt
/ck:plan --fast Change the CTA copy in the Pricing section Use when
The task is small, low-dependency, and easy to roll back.
Expected
A quick plan without heavy research, red-team, or validation.
--hard Hard Sample prompt
/ck:plan --hard Refactor auth flow while preserving backward compatibility Use when
There are real technical constraints, but not a per-phase deep refactor.
Expected
Research and red-team catch architectural risk early.
--deep Deep Sample prompt
/ck:plan --deep Split billing into subscription, invoice, webhook modules Use when
The refactor is large, dependency-heavy, and touches multiple modules.
Expected
Deeper research, stronger validation, and evidence-backed phases.
--parallel Parallel Sample prompt
/ck:plan --parallel Optimize dashboard loading and chart rendering Use when
The work can be split into independent tracks.
Expected
Clear boundaries that can be handed to cook with --parallel.
--two Two approaches Sample prompt
/ck:plan --two Choose an offline-first data sync architecture Use when
Two approaches must be compared before committing to a plan.
Expected
Both approaches are analyzed first, then one direction is selected.
Combine with a mode to change how the plan handles tests or tasks.
--tdd Tests-first per phase
Composable flag: adds tests-first structure to each phase.
Sample prompt
/ck:plan --deep --tdd Refactor billing module Use when
--deep --tdd is the main combo for major refactors or logic with important contracts.
--no-tasks Skip task hydration
Do not create Claude Tasks after the plan is generated.
Sample prompt
/ck:plan --fast --no-tasks Update guide copy Use when
Best for small or docs-only plans where extra task creation is not needed yet.
Compose With Modes
--tdd can combine with any mode, but pick the mode from scope first.
--hard --tdd Complex, needs research
Use when the task is complex but not a major multi-area refactor.
--deep --tdd Recommended Recommended for risky refactors
Use for large refactors, 5+ areas, architectural debt, or per-phase scouting.
--parallel --tdd Niche: parallel + tests-first
Use only when independent workstreams can run in parallel and each lane still needs test gates.
--deep --tdd → Quick Ref / Implementation command
After /ck:plan or feature brief
Use it when a plan or feature brief must become working code. Scout first, lock 5 requirements, pass plan gates, implement, test, review, then sync plan/docs/git/journal.
Plan path / brief
Scout + reqs
Code + test
Review + sync
Plan-first
Even small work needs plan review before code.
Scout-first
Summarize 3-6 repo findings before any AskUser.
No side effects
Acceptance, tests, contracts, lint/type/build must stay clean.
Four lanes: orient intent, create an evidence-backed plan, implement/test, then review and sync artifacts.
Orient
Mode, scout, requirements
Plan
Research + plan review
Build
Implement, simplify, test
Close
Review, sync, journal
Interactive is the default. Use flags to skip research, auto-approve, run in parallel, or execute an existing plan path.
plan path Code mode
Skip scout/research/plan and execute existing phase files.
Prompt
/ck:cook /abs/plans/260524-auth/plan.md Use when: A reviewed plan was produced by /ck:plan or handed off from another session.
Expected: Reads phase files, implements each phase, then tests/reviews/finalizes.
--fast Fast
Skip heavy research but still run scout -> plan -> code.
Prompt
/ck:cook --fast Change CTA copy in Pricing Use when: Small scope, easy rollback, few dependencies.
Expected: Short plan with user gates still held before code.
--auto Auto
Auto-approve low-risk work when artifacts + validator pass; high-risk changes still stop for user approval before finalize/commit/ship.
Prompt
/ck:cook --auto Add cache to the stats endpoint Use when: You trust the agent, risk is low, and acceptance is clear.
Expected: Runs low-risk phases continuously while still testing and reviewing; score is advisory, never approves on its own.
--parallel Parallel
Split independent features into separate lanes.
Prompt
/ck:cook --parallel Implement search, filters, export CSV Use when: 3+ workstreams have clear file ownership.
Expected: Multi-agent lanes merge through review gates.
/ck:cook /abs/plans/260524-auth/plan.md Use when: A plan.md and phase files already exist.
Expected: Uses plan context instead of rediscovering the task.
/ck:cook Add email/password login with httpOnly session Use when: No plan exists, but the desired output is clear.
Expected: Scout -> 5 requirements -> research/plan -> implement.
/ck:cook --tdd Refactor billing calculation while preserving behavior Use when: Refactor or critical logic.
Expected: Tests current behavior first, then verifies after implementation.
Implementation Complete
Commits + plan status synced + journal entry Code merged via git-manager
Tests 100% pass
code-reviewer approved (no regression, contracts intact)
plan.md + all phase-XX.md status synced via /ck:project-management
docs updated
/ck:journal entry recorded
Thought
This is simple, just code it
Reality
Simple tasks still hide contracts. Planning is cheaper than rewriting.
Thought
Ask the user before reading the repo
Reality
AskUser options must come from scout findings, not generic questions.
Thought
Tests pass, done
Reality
Touchpoints, contracts, lint/type/build, and code-review still have to clear.
Quick Ref / Command
Engineer Kit
Polished frontend interface creation from briefs, screenshots, videos, 3D ideas, or redesign audits. Design-first, anti-slop, visually verified.
Classify
Design Intel
Dials
Analyze
Design intelligence first
Screenshot/video replication
Anti-slop beats generic defaults
3D/WebGL hero experiences
Analyze source media before implementation
Design dials and aesthetic direction
Core lanes from input to output, aligned with the command's real execution path.
Understand
Classify + design intel
Define
Dials + analyze source
Build
Direction + implementation
Verify
Anti-slop + responsive
Screenshot Screenshot Replication Pixel, spacing, color, and font matched replication from a static image.
Prompt
/ck:frontend-design Recreate this checkout UI from @checkout.png Video Video Replication Layout, timing, easing, and interaction behavior from video source.
Prompt
/ck:frontend-design Replicate this onboarding animation from @demo.mp4 3D/WebGL 3D / WebGL Three.js immersive scene with 60fps target and full-bleed layout.
Prompt
/ck:frontend-design Build an immersive Three.js hero for the launch page Redesign Redesign Audit and improve existing UI without rewriting the stack.
Prompt
/ck:frontend-design Redesign the pricing page without changing the stack "Start building, we can analyze the screenshot later"
Always analyze source media before implementation. Missing details in screenshots lead to wrong spacing, colors, and interactions.
"Use a generic card component, it is good enough"
Anti-slop rules override generic defaults. Design intelligence must be activated first; generic components are only acceptable when they match the specific design direction.
"Redesign by switching to a different UI framework"
Redesigns must keep the existing stack and routes. Framework swaps require separate planning and are outside the redesign scope.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:frontend-design Recreate this checkout screenshot exactly from @checkout.png /ck:frontend-design Replicate this onboarding animation from @demo.mp4 /ck:frontend-design Describe this settings screen from @settings.png for handoff only /ck:frontend-design Build an immersive Three.js hero for a developer tools dashboard /ck:frontend-design Polish the command palette empty state and mobile spacing /ck:frontend-design Create an award-quality interactive launch page for VividKit Desktop /ck:frontend-design Redesign the current pricing page without changing the stack Working UI + Verification
Pattern
implemented files + visual check notes + optional docs/design-guidelines.md Final delivery includes working code, visual verification notes, anti-slop/performance checks, and documentation updates when approved.
Quick Ref / Review command
After /ck:cook or /ck:fix, before /ck:ship
Use it when code needs adversarial-rigor review. Resolve input mode, pass the spec-compliance gate, scout edge cases, run the code-reviewer sub-agent, then let the adversarial red-team actively try to break the code before verify + report.
Input + diff
Spec gate
Quality + scout
Adversarial + report
Spec-first gate
Stage 1 must pass — never skip to Stage 2 with spec mismatch.
Adversarial always-on
Stage 3 red-team runs every time. Scope gate exempts only trivial.
Fresh evidence
No "done" claim without rerunning tests/build with new output.
Four lanes: resolve input + diff, pass the spec gate, run quality review with scout, then adversarial red-team + verify + report.
Resolve
Input mode + diff acquisition
Spec gate
Stage 1 — code matches plan/spec?
Quality
Scout edge cases + Stage 2 code-reviewer
Adversarial + Prove
Stage 3 red-team, verify, report
Input mode picks the review target. Pick ONE — agent auto-detects from the argument, or AskUserQuestion when ambiguous. No "fast/auto" flag — every mode runs through all 3 stages.
#123 PR mode
Fetch full PR diff via gh pr diff #N.
Prompt
/ck:code-review #123 Use when: Reviewing an open GitHub PR.
Expected: Full PR diff → 3-stage review → APPROVE / REQUEST CHANGES / BLOCK recommendation.
--pending Pending
Review staged + unstaged changes in the working tree.
Prompt
/ck:code-review --pending Use when: Before commit, right after /ck:cook or /ck:fix.
Expected: git diff (staged + unstaged) → 3-stage review → inline findings.
abc1234 Commit
Review a specific commit via git show <sha>.
Prompt
/ck:code-review abc1234 Use when: Auditing an old commit, post-mortem regression.
Expected: That commit's diff → 3-stage review scoped to the commit.
codebase parallel Codebase parallel
Ultrathink edge cases, then spawn adversarial reviewers in parallel.
Prompt
/ck:code-review codebase parallel Use when: Deep audits — security review, pre-launch hardening.
Expected: Multiple scoped reviewers, dedupe + prioritize by severity.
/ck:code-review --pending Use when: Just finished /ck:cook or /ck:fix, not yet committed.
Expected: Reviews all staged + unstaged before commit / ship.
/ck:code-review #42 Use when: PR is open, needs adversarial review before merge.
Expected: Findings grouped by severity + verdict per item.
/ck:code-review codebase parallel Use when: Pre-launch or whole-project security audit.
Expected: Multiple scoped reviewers, severity-dedupe in the report.
Adversarial Review Report
Findings grouped by severity (Critical / Important / Minor) + verdict per finding + merge recommendation Each finding: description, file:line, severity, verdict (Accept / Reject / Defer)
Critical → BLOCK merge
Deferred → GitHub issue
Recommendation: APPROVE | REQUEST CHANGES | BLOCK
Verification gate (tests + build) MUST pass before report finalizes
Thought
Code compiles → review passes
Reality
Stage 1 spec compliance must verify intent matches plan/spec — compile says nothing.
Thought
Small diff, just skim it
Reality
Adversarial Stage 3 is still mandatory unless the scope gate hits (≤2 files, ≤30 lines, no security).
Thought
Tests pass = safe to merge
Reality
Critical findings still block merge. Need fresh build + test evidence — no "should/probably".
Quick Ref / Command
Engineer Kit
Evidence-based GitHub PR review for correctness, security, breaking changes, and AI-slop — with optional fix loop and a formal reply posted back to GitHub.
Acquire
Gates
Review
Anti-slop
Evidence over rubber-stamp
Correctness and security review
Duplicate, standards, and value gates first
Breaking-change detection
Read full files, not just hunks
AI-slop taxonomy
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
default Review-only, findings to chat
--fix Remediation loop on PR head
--reply Post formal review to GitHub
--fix --reply Fix loop, then post final re-review
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:review-pr 123 /ck:review-pr https://github.com/org/repo/pull/123 /ck:review-pr 123 --fix /ck:review-pr 123 --reply /ck:review-pr 123 --fix --reply /ck:review-pr 456 Review Report + Optional GitHub Review
Pattern
Summary + gate results + findings by severity + verdict; gh pr review on --reply Prints a structured review (risk level, duplicate/standards/strategic gates, Critical/Important/Suggestion findings, verdict). With --reply, posts the body to GitHub mapped to the verdict, with a traceability footer and local-print fallback.
Quick Ref / Command
Engineer Kit
Testing and QA workflow for unit, integration, e2e, build, coverage, and browser/UI validation.
Dispatch
Scope
Pre-flight
Execute
Never ignore failing tests
Test runner detection
Root cause over symptom
Failure analysis
Pre-flight before test execution
Coverage reporting
Core lanes from input to output, aligned with the command's real execution path.
Dispatch
Scope + pre-flight
Execute
Runner + analyze
Measure
Coverage + UI verify
Report
Structured QA output
[context] Code Tests Run unit, integration, e2e, coverage, and build validation for a code scope.
Prompt
/ck:test recent changes in auth module ui [url] UI / Browser QA Browser, screenshot, responsive, and a11y checks on a running page.
Prompt
/ck:test ui http://localhost:4321/guides (no args) Operation Picker Asks which test operation to run when no context is provided.
Prompt
/ck:test "Tests fail but the feature works, ignore them"
Never ignore failing tests. Fix root causes, not symptoms. Failing tests protect future changes.
"Mock the dependency to make the test pass"
No mocks or cheats to force passing builds. Tests must reflect real behavior or they provide false confidence.
"UI report mode will fix the issues it finds"
UI workflow with url argument is report-only. It captures evidence; fixes require a separate implementation step.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:test /ck:test recent changes in checkout /ck:test ui http://localhost:4321/guides/how-ck-works QA Report
Pattern
test results + coverage + failures + UI findings + build status Reports pass/fail counts, failure root causes, coverage, UI findings, build status, recommendations, and unresolved questions.
Quick Ref / Fix command
Bug, failing CI, regression, production issue
Use it when a failure needs an evidence-based repair. Pick mode, scout first, diagnose root cause, fix the cause, verify/prevent, review, then finalize.
Mode
Scout + diagnose
Root-cause fix
Verify + prevent
Root cause first
No symptom patches, no probably.
Exact repro
Capture pre-fix failure and rerun the same path.
Prevention
Regression test, blast-radius sweep, guards against recurrence.
Four lanes: mode/scout, root-cause diagnosis, targeted repair, then verify/prevent + finalize.
Start
Mode + scout evidence
Diagnose
RCA with file:line
Repair
Address the root cause
Prove
Verify, prevent, finalize
Autonomous is the default. Use review for high risk, quick only for tiny lint/type fixes, and parallel for independent issues.
--auto Autonomous
Auto-approve only when artifacts + validator pass.
Prompt
/ck:fix --auto login button returns 500 Use when: The bug is clear, risk is low/moderate, and verification is straightforward.
Expected: Still runs scout/diagnose/review before finalize.
--review Human review
Pause at each step for user approval.
Prompt
/ck:fix --review webhook duplicate charge Use when: Production, billing, auth, data loss, or public contract risk.
Expected: Stops after diagnosis/fix/verify with concrete findings.
--quick Quick
Scout -> diagnose -> fix -> lighter review.
Prompt
/ck:fix --quick TypeScript error in pricing card Use when: Trivial lint/type/single-file issue.
Expected: Faster cycle without skipping root-cause checks.
--parallel Parallel
One fullstack-developer lane per independent issue.
Prompt
/ck:fix --parallel checkout errors and dashboard chart crash Use when: 2+ independent failures with separate touchpoints.
Expected: Separate task trees; main agent surfaces cross-issue conflicts.
/ck:fix Login submit returns 500 in local dev Use when: Let the agent choose mode and scout the repo.
Expected: Mode -> Scout -> Diagnose -> Root-cause fix -> Verify.
/ck:fix --review Payment webhook double-charges paid orders Use when: You want a user gate at every step.
Expected: No finalize/commit before user approval.
/ck:fix --quick npm run build fails after latest merge Use when: Build/type/lint failure appears small.
Expected: Fast repair while rerunning the exact failing command.
Bug Fix Report
Step markers + confidence score + journal entry Root cause cited file:line
Fix targeted
Regression test added
Blast-radius swept
Prevention guards in place
Plan/tasks synced
Docs updated
Journal recorded
Thought
I can see the bug, just fix it
Reality
Seeing symptoms is not root cause. Scout + diagnose first.
Thought
Try changing X and see
Reality
Random fixes create new bugs. Build an evidence chain.
Thought
Fixed, tests pass
Reality
The prevention gate still needs to stop this bug class from recurring.
Quick Ref / Command
Engineer Kit
Lightweight security scanner for hardcoded secrets, dependency issues, and common OWASP-style code patterns.
Detect
Secrets
Deps
Patterns
Secrets run first
Secret detection
No raw secret output
Dependency audit
Report-only, no automatic code changes
OWASP-style code patterns
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
--secrets-only Only secret and credential detection
--deps-only Only dependency audit
--full Full project scan
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:security-scan src/api/ /ck:security-scan --secrets-only /ck:security-scan --deps-only /ck:security-scan --full Security Scan Report
Pattern
chat markdown report or plans/reports/security-scan-{date}.md in cook --auto Includes project, scan date, files checked, severity summary by Secrets/Deps/Code, findings, and recommendations.
Quick Ref / Command
Engineer Kit
Unified ship pipeline from feature branch to PR URL: issue trace, merge target, test, review, version, changelog, commit, push, and PR.
Pre-flight
Issues
Merge
Tests
One command from branch to PR URL
Branch safety
Never force push
Issue/PR traceability
Tests and critical review issues block
Test runner detection
Core lanes from input to output, aligned with the command's real execution path.
Pre-flight
Branch, mode, issues
Validate
Tests + code review
Release
Version, changelog, commit
Ship
Push + PR URL
official Official Full pipeline targeting main/master with docs and changelog.
Prompt
/ck:ship beta Beta Target dev/beta/develop; skip docs update.
Prompt
/ck:ship beta --dry-run Dry Run Show plan and stop after pre-flight check.
Prompt
/ck:ship --dry-run "Tests pass, just push"
Code review must pass too. Review catches logic bugs that tests miss.
"Force push to fix the commit"
Ship never force pushes. Create a new commit instead.
"Skip version bump, it is just a small fix"
Every ship produces a version. Patch for fixes, minor/major requires user approval.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:ship official /ck:ship beta /ck:ship official --skip-tests /ck:ship beta --skip-review /ck:ship official --skip-journal /ck:ship official --skip-docs /ck:ship --dry-run Pull Request Created
Pattern
PR URL + linked issues + test/review results + ship mode Final visible output is the PR URL with structured body and linked issues.
Quick Ref / Command
Engineer Kit
Full autonomous pipeline that takes a GitHub issue or feature request from planning through implementation, PR review, and optional merge with CI convergence.
Parse
Worktree
Plan + Gates
Issue
One command from request to PR
Issue-to-PR orchestration
Treat the GitHub issue as source of truth
Worktree isolation
Always validate and red-team the plan
TDD planning gates
Core lanes from input to output, aligned with the command's real execution path.
Intake
Parse + worktree
Plan
Plan gates + issue
Build
Cook or fix
Ship
Review PR + merge
default PR Only (Default) No --ship: stops once the PR is reviewed, fixed, replied, and labeled ready to ship stable.
Prompt
/ck:vibe https://github.com/org/repo/issues/42 --ship Ship + CI Watch Merges the PR per branch protection and watches/fixes target-branch CI until green or a true external blocker.
Prompt
/ck:vibe --ship https://github.com/org/repo/issues/42 --beta Beta Target Ships to beta/dev via /ck:ship beta with final label ready to ship beta.
Prompt
/ck:vibe --ship --beta https://github.com/org/repo/issues/42 route Cook vs Fix Routing Bug, regression, or failing CI routes to /ck:fix --auto; net-new or refactor routes to /ck:cook --tdd --auto.
Prompt
/ck:vibe https://github.com/org/repo/issues/57 "Vibe writes the production code itself"
It orchestrates /ck:plan, /ck:cook, /ck:fix, /ck:ship, and /ck:review-pr. Each underlying skill keeps its own gates; vibe never bypasses them.
"--ship will merge no matter what"
--ship merges per branch protection and required checks. It never force-pushes or direct-pushes a protected branch, and stops on a true external blocker.
"CI failures can be hidden to get green"
Missing secrets, unavailable services, or required human approval are recorded as external blockers. Tests are never weakened to pass.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:vibe https://github.com/org/repo/issues/42 /ck:vibe --ship https://github.com/org/repo/issues/42 /ck:vibe --ship --beta https://github.com/org/repo/issues/42 /ck:vibe --ship "Add CSV export to the reports page" /ck:vibe https://github.com/org/repo/issues/57 /ck:vibe https://github.com/org/repo/issues/61 Vibe Result Report
Pattern
Source, branch/worktree, plan, issue URL, PR URL, mode, route, review, merge, CI status Ends with a Vibe Result block linking the issue and PR, plus mode (official/beta), route (feature/bugfix), review outcome with fix iterations, merge status (skipped/merged/blocked), and CI status (green/failed/blocked).
Quick Ref / Command
Engineer Kit
Auto-detects deployment target, runs the selected platform deploy, verifies the URL, and records docs/deployment.md.
Detect
Recommend
Ask
CLI/Auth
Detect-first deployment
Platform config detection
Ask before choosing if no target is detected
Cost-aware recommendation
Secret-safe output
CLI auth/deploy
Core lanes from input to output, aligned with the command's real execution path.
Detect
Target + platform
Deploy
CLI + run
Confirm
URL + docs
(auto) Auto-detect Reads deployment docs, config files, and project type to choose the best platform.
Prompt
/ck:deploy [platform] Named Platform Target a specific hosting platform by name.
Prompt
/ck:deploy vercel [platform] [env] Platform + Env Specify both provider and environment for production-safe deploy.
Prompt
/ck:deploy cloudflare production "Just deploy, docs can come later"
Deployment docs must be created or updated every time. They become the source of truth for rollback and future deploys.
"I can put the API key in the deploy command"
Never expose secrets in deploy output or logs. Use platform environment variable vaults.
"The deploy command succeeded so the app is live"
Always verify the deployment URL after every deploy. A successful CLI exit does not guarantee the URL is reachable.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:deploy /ck:deploy vercel /ck:deploy production /ck:deploy cloudflare production Deployment Docs
Pattern
docs/deployment.md Records platform, production URL, deploy command, env vars, custom domain, rollback, and troubleshooting.
End-to-end project bootstrapping from idea to running code. Default is interactive; autonomous behavior requires an explicit flag.
01
Repo + scope
02
Research + design
03
Plan -> Cook
04
Docs + handoff
Default interactive
New project architecture
Delegate plan then cook
Stack selection
Docs under ./docs and plans under ./plans
Design scaffolding
Main pipeline: initialize repo, research/design, plan, cook the implementation, then close with docs and handoff.
Start
Repo, requirements, mode
Discovery
Research, stack, design gate
Build
ck:plan -> ck:cook
Close
Docs, onboard, report
--full Recommended Default interactive; gates every major phase; ck:plan --hard
--auto Explicit autonomous; design gate only; ck:plan/cook --auto
--fast Fast path; ck:plan --fast; interactive cook gates remain
--parallel Parallel plan/cook with design gate
Each row is a concrete invocation for a supported mode.
/ck:bootstrap "Customer support portal with auth and ticket inbox" --full /ck:bootstrap "Internal CRM with import/export" --auto /ck:bootstrap "Static docs site for API examples" --fast /ck:bootstrap "SaaS analytics app with billing and dashboard" --parallel Bootstrapped Project
./docs + ./plans + final report + unresolved questions Creates project docs, plans, implementation, onboarding notes, final report, and journal entry.
Quick Ref / Command
Engineer Kit
Autoresearch family router: chooses loop, predict, scenario, or security workflows for bounded autonomous iteration.
Ask
Classify
Route
Bound
Router first
Autonomous metric loops
Bound every loop
Persona prediction
Verify before keep
Scenario generation
Core lanes from input to output, aligned with the command's real execution path.
Classify
Intent → family
Route
Dispatch to skill
Iterate
Bounded loops
Emit
Artifact + follow-up
/ck:loop Metric Loop Bounded atomic keep/discard loop until a numeric goal is met.
Prompt
/ck:loop Goal: branch coverage >80 | Scope: src/**/*.ts | Verify: npm run coverage:score | Iterations: 8 /ck:predict Predict Five-persona GO/CAUTION/STOP debate on a proposal before implementation.
Prompt
/ck:predict "Add Redis sessions" --files src/auth/** /ck:scenario Scenario Edge-case discovery with novelty deduplication and saturation stop.
Prompt
/ck:scenario src/checkout.ts --saturation --domain security /ck:security Security STRIDE/OWASP audit with optional red-team and fix loop.
Prompt
/ck:security full --red-team --iterations 12 "Just run autoresearch, it will figure out the workflow"
autoresearch is a router, not an executor. It maps you to the right family skill; it does not run loops or audits directly.
"The loop succeeded, keep all changes"
Only keep changes verified by the Verify command. Failed Verify or Guard condition means discard and revert.
"Increase iterations for better results"
Unbounded loops risk runaway cost and inconsistent state. Always set a finite Iterations value and a Guard condition.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:autoresearch Which autoresearch-family command should improve coverage safely? /ck:loop Goal: raise branch coverage | Scope: src/**/*.ts | Verify: npm run coverage:score | Iterations: 8 | Direction: higher /ck:predict "Add organization roles and project permissions" --files src/**/*.ts /ck:predict "Choose session cookies vs JWT" --chain reason /ck:predict "Move guide data loading to runtime API" --chain probe /ck:scenario src/middleware/auth.ts --saturation --domain security --focus security /ck:security src/api/**/*.ts --red-team --iterations 16 /ck:security full --red-team --fix --iterations 10 Routed Autoresearch Artifacts
Pattern
family map, prediction/scenario/security reports, loop-results.tsv, security-audit-results.tsv Outputs depend on routed workflow: family map, bounded loop metrics, prediction verdict, scenario coverage, or security audit/fix report.
Quick Ref / Command
Engineer Kit
Backend capability router for APIs, auth, databases, performance, microservices, tests, and production operations.
Target
Scout
Contract
Data + Auth
Contract before code
REST/GraphQL/gRPC APIs
Security on every public endpoint
Authentication and RBAC
Migrations need rollback
Database schema and performance
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
API design REST, GraphQL, or gRPC contract route
Auth/security OAuth, JWT, RBAC, MFA, OWASP route
Data/perf Postgres, MongoDB, Redis, indexes, caching
Architecture Monolith, microservices, CQRS, saga, events
Ops Docker, Kubernetes, CI/CD, observability
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:backend-development NestJS build a REST orders API with PostgreSQL migrations, RBAC, and OpenAPI docs /ck:backend-development FastAPI design OAuth 2.1 login with PKCE, refresh rotation, and Redis sessions /ck:backend-development Django optimize slow admin reports using indexes, query plans, and caching /ck:backend-development Go Gin create a gRPC inventory service with protobuf contracts and contract tests /ck:backend-development Node.js add Redis cache-aside for product search without stale pricing /ck:backend-development microservices split billing into invoice, subscription, and webhook services with saga compensation /ck:backend-development testing add unit, integration, E2E, migration, and load tests for checkout APIs /ck:backend-development devops containerize the API with Docker, Kubernetes health checks, canary deploy, and OpenTelemetry Backend Deliverables
Pattern
API contracts + modules/services + migrations + tests + deploy/observability assets Outputs depend on route: contracts, backend modules, auth policies, schemas, migrations, tests, containers, CI, monitoring, docs, and runbooks.
Quick Ref / Command
Engineer Kit
Better Auth setup for TypeScript apps: email/password, OAuth, MFA, passkeys, organizations, sessions, and production hardening.
Detect
Choose
Configure
Schema
TypeScript app first
Email/password auth
Database before schema
OAuth providers
Never expose secrets
MFA and passkeys
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
email/password Built-in credential auth
oauth GitHub, Google, or social providers
2FA/passkeys MFA and passwordless plugins
organizations Teams, tenants, roles, invites
production Sessions, cookies, rate limits, email
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:better-auth add email/password auth to this Next.js app with PostgreSQL /ck:better-auth configure GitHub and Google OAuth with account linking /ck:better-auth set up Better Auth with Prisma and generate the schema /ck:better-auth add 2FA with TOTP, backup codes, and admin-only enforcement /ck:better-auth add passkeys as a passwordless option while keeping password fallback /ck:better-auth implement magic link login with short-lived links /ck:better-auth add organization support with owner/admin/member roles /ck:better-auth harden sessions, secure cookies, revoke devices, and rate-limit sign-in Auth Implementation Assets
Pattern
auth server/client config + API route + schema/migrations + auth UI + protected routes Outputs Better Auth server and client setup, generated schema or migrations, route handlers, UI flows, protected route middleware, and validation notes.
Quick Ref / Command
Engineer Kit
Diagnose context budgets, degradation, compression, memory, multi-agent isolation, evaluation, and tool design.
Classify
Load Narrow
Inspect
Score Risk
Context quality beats quantity
Token budgets
Measure before optimizing
Context degradation
Progressive disclosure
Compression quality
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
runtime Usage and context-window awareness
degradation Lost-in-middle, poisoning, stale context
optimization Compaction, masking, cache ordering
memory Cross-session memory architecture
multi-agent Context isolation and coordination
tool design Tool consolidation and clearer descriptions
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:context-engineering why is this session getting worse after long debugging? /ck:context-engineering check whether our current context needs compaction before continuing /ck:context-engineering design a token budget for an agent with tools, docs retrieval, and long history /ck:context-engineering analyze this context file with a 200k token limit and auth, migration, rollback as critical keywords /ck:context-engineering generate probe questions to test whether this compacted handoff preserves file changes and decisions /ck:context-engineering compare single-agent vs multi-agent design for this repo analysis pipeline /ck:context-engineering design a memory system for cross-session project decisions /ck:context-engineering reduce our MCP tool list without losing capability Context Engineering Artifacts
Pattern
context health report, budget JSON, compression evaluation, probe set, memory/tool design audit Outputs diagnostics and reusable artifacts for context health, token budgets, compression quality, memory layers, and tool simplification.
Quick Ref / Command
Engineer Kit
Current documentation lookup via llms.txt and Context7, with topic/general routing and repository fallback.
Parse
Detect
Fetch
Analyze
Scripts first
Context7 docs lookup
Official docs over tutorials
llms.txt analysis
Fallback deliberately
Versioned documentation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
topic-search Specific feature, component, or API
library-search General documentation sweep
repo-analysis Fallback when docs are missing
version-specific Versioned docs or explicit caveat
plugin-focused Narrow a broad ecosystem to one plugin
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:docs-seeker Next.js caching strategies /ck:docs-seeker shadcn/ui date picker /ck:docs-seeker Documentation for Astro /ck:docs-seeker Better Auth OAuth setup /ck:docs-seeker React Hook Form v8 migration docs /ck:docs-seeker SvelteKit docs in Japanese /ck:docs-seeker Fastify plugins: auth only /ck:docs-seeker analyze docs for github.com/org/obscure-library Documentation Lookup Result
Pattern
classification JSON + fetched docs/URL groups + source-cited answer or repo fallback report Outputs query classification, fetched docs or URL priority groups, fallback notes, and a concise answer with source confidence.
Quick Ref / Command
Engineer Kit
Turns a visual concept into approved image prompts, then renders through Google or OpenRouter-backed image generation.
Parse
Interview
Follow-up
Preview
Interview before rendering
Prompt search
Preview before generation
Image generation
Edit loops before spend
Visual direction
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
--mode search Best prompt match from curated database
--mode creative Remix top matching prompt elements
--mode wild Apply a strong random visual transformation
--mode all Generate search, creative, and wild variants
--provider auto, google, or openrouter provider route
--skip Bypass interview and use defaults
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:ai-artist "tech conference banner" /ck:ai-artist "developer dashboard hero image" --mode search /ck:ai-artist "AI workshop social poster" --mode creative /ck:ai-artist "product showcase for VividKit Desktop" --mode wild /ck:ai-artist "futuristic city for launch campaign" --mode all /ck:ai-artist "minimal product mockup" --provider google /ck:ai-artist "conference booth backdrop" --provider openrouter /ck:ai-artist "LinkedIn banner for AI coding tools" --skip Generated Image Assets
Pattern
PNG output path; --mode all creates -search, -creative, -wild variants Outputs approved prompt preview, PNG image assets, and final status with output path, style, mood, and aspect.
Quick Ref / Command
Engineer Kit
Wrap existing code as a reusable CLI, MCP server, or both, with shared core, credentials, docs, tests, CI, and companion skill.
Track
Scout
Map
Decide
Track before work
CLI packaging
Scout before design
MCP servers
Core before adapters
Shared core design
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
--both Default; shared core plus CLI and MCP packages
--mcp MCP server only
--cli CLI package only
--auto Proceed with recorded decisions
--ask Pause for clarification before scaffolding
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:agentize src/integrations/payments /ck:agentize packages/reporting --both /ck:agentize src/search --mcp /ck:agentize scripts/importer --cli /ck:agentize src/billing --auto /ck:agentize src/billing --ask /ck:agentize src/browser-automation --mcp --ask Agentized Package Set
Pattern
plans/<plan>/plan.md + packages/core|cli|mcp + docs + CI + release checklist Outputs shared core, CLI/MCP adapters, documentation, CI, companion skill, and release checklist.
Quick Ref / Command
Engineer Kit
Cyber threat intelligence and OSINT workflow for public-data investigations, exposure reviews, domain recon, breach checks, and structured reports.
Acquire
Enrich
Parallelize
Assess
Public data only
OSINT
Authorization before security testing
Threat intelligence
Corroborate high-risk findings
Exposure review
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
--case Structured case workflow
--sweep Broad evidence sweep
--query Query-led OSINT investigation
--flow Guided person/domain/email/quick flow
--yolo Autonomous mode with mandatory boundaries
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:cti-expert target.com --case /ck:cti-expert @alice --sweep /ck:cti-expert "Acme Corp" --query /ck:cti-expert person --flow /ck:cti-expert target.com --case --yolo /report ioc --format stix Structured Intelligence Report
Pattern
OSINT-REPORT-[CASE-ID]-[YYYY-MM-DD].md/.docx + optional IOC STIX/TXT/CSV Auto-saves Markdown and Word reports with source citations, confidence levels, limitations, visuals, workspace artifacts, and optional IOC exports.
Quick Ref / Command
Engineer Kit
Data-driven retrospective from git history: velocity, churn, hotspots, plans, and team activity.
Parse Period
Collect Git
Compute Health
Scan Plans
Read-only
Git metrics
No guessed metrics
Team activity
Date ranges are explicit
Code health
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
7d/default Default last-seven-days retro
sprint Sprint range; ask if start is unclear
--compare Compare with previous equal-length period
--team Per-author breakdown
--format html Self-contained HTML report
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:retro /ck:retro 2w /ck:retro sprint /ck:retro 2026-05-01:2026-05-31 /ck:retro 2w --compare /ck:retro 1m --team /ck:retro sprint --format html Retrospective Report
Pattern
plans/reports/retro-{YYMMDD}-{slug}.md or .html Outputs velocity, code health, commit distribution, hotspots, plan progress, optional team breakdown, highlights, and recommendations.
Quick Ref / Command
Engineer Kit
Turn code, docs, papers, images, and media into a queryable architecture graph for planning and navigation.
Input
Local Extract
Semantic Extract
Tag Edges
Local-first code extraction
Knowledge graphs
Confidence tags on edges
Architecture navigation
Graph before planning
Semantic extraction
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
[path] Build graph for provided path
--watch Incremental rebuild on file changes
--report Generate/use graph report
--mcp Expose graph through MCP tools
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:graphify /ck:graphify /path/to/project /ck:graphify . --watch /ck:graphify . --report /ck:graphify . --mcp /ck:graphify . --report Graphify Artifacts
Pattern
graphify-out/graph.html + GRAPH_REPORT.md + graph.json + cache/ Outputs an interactive graph, architecture report, queryable JSON graph, and cache for incremental rebuilds.
Quick Ref / Command
Engineer Kit
Guarded Git delivery for commits, pushes, pull requests, and merges with secret scanning and conventional messages.
Choose
Inspect
Scan
Split
Secret scan blocks commit
Conventional commits
Push only when asked
Commit splitting
Remote diff for PRs
Secret scanning
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
cm Commit only
cp Commit and push
pr [to] [from] Create GitHub PR from remote diff
merge [to] [from] Merge remote source into target branch
[no args] Ask operation first
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:git /ck:git cm /ck:git cp /ck:git pr /ck:git pr develop /ck:git pr main feature/oauth-login /ck:git merge /ck:git merge develop feature/oauth-login Git Delivery Artifacts
Pattern
commits + optional pushed branch + PR URL + merge summary Outputs one or more commits, optional push/PR/merge result, and a concise delivery summary.
Quick Ref / Command
Engineer Kit
GitHub project management for humans and AI agents: turn requests into issues, track status and handoffs on Projects, and automate triage with gh, GraphQL, and Actions.
Orient
Choose Mode
Load References
Update GitHub
GitHub is the single source of truth
Issue/task intake
Update GitHub first, then local artifacts
Projects boards + fields
One mutually-exclusive live status
Label taxonomy
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Bootstrap Create labels, project fields, templates, automation
Intake Turn request/plan/chat into GitHub issues
Execute Link branch/PR/checks and advance status
Handoff Write state, blockers, commands, next owner
Audit Compare GitHub state vs repo/plans/CI
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:ghpm turn this plan into GitHub issues with owners and acceptance criteria /ck:ghpm set up minimal labels and a Project board for this repo /ck:ghpm move issue #123 to in-progress and link the PR /ck:ghpm write a handoff comment for issue #123 with commands run and next step /ck:ghpm audit open issues and the board against local plans and CI /ck:ghpm summarize current project status from GitHub state /ck:ghpm set the Status field for issue #123 to In Progress on the org Project /ck:ghpm run the project-triage workflow for issue #123 Evidence-Based GHPM Status
Pattern
GitHub issues (task contract) + Project fields + append-only handoff comments + cited status summary Produces structured issues, live Project state, and a concise status citing repo, project URL, issue states/owners/priorities, Actions/check results, and the last handoff comment with next owner/action.
Quick Ref / Command
Engineer Kit
Evidence-first debugging that proves root cause before routing into a fix.
Assess
Collect
Trace
Compare
Evidence before hypothesis
Root-cause tracing
One hypothesis at a time
CI log analysis
Fix root cause, not symptom
Performance debugging
Core lanes from input to output, aligned with the command's real execution path.
Gather
Symptoms, evidence, repro
Analyze
Trace + compare + hypothesis
Fix
Root cause + regression
Prove
Fresh verification
Code bug Trace application error to root cause
CI/CD Compare CI logs and environment state
Performance Quantify and isolate bottleneck layer
Frontend Use screenshot, DOM, console, responsive checks
Polluter helper Find tests that leave unwanted files/state
"I see the bug, fix it now"
Seeing a symptom is not diagnosing root cause. Collect evidence first.
"Try changing X and see"
Random fixes create new bugs. Test one hypothesis with the smallest experiment.
"Tests pass now, done"
Need fresh verification from command/browser, not just test suite green.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:debug "checkout returns 500 after payment webhook" /ck:debug "TypeError: user.validate is not a function in auth middleware" /ck:debug "npm test fails only in CI, passes locally" /ck:debug "git init runs in the wrong directory during workspace creation" /ck:debug "API latency spiked after the last deploy" /ck:debug "settings page layout overlaps on mobile" ./find-polluter.sh ".git" "src/**/*.test.ts" Debug Evidence
Pattern
repro steps + hypothesis log + verification output + optional debug report Outputs the root-cause chain, confirmed/rejected hypotheses, regression check, and fresh verification evidence.
Quick Ref / Command
Engineer Kit
Browser automation and QA evidence workflow built around snapshot refs, actions, waits, and artifacts.
Verify
Load Guide
Open
Snapshot
Snapshot refs expire
Browser automation
Evidence is first-class
QA screenshots/video
Do not leak auth artifacts
CDP/Electron
Core lanes from input to output, aligned with the command's real execution path.
Setup
Verify + load + open
Observe
Snapshot refs
Act
Interact + wait
Evidence
Capture artifacts
open/snapshot/act Core Loop Open a URL, take a snapshot for interactive refs, then act on those refs.
Prompt
agent-browser open http://localhost:3000 && agent-browser snapshot -i -c && agent-browser click @e7 dogfood QA Dogfood QA Exploratory testing of the live app through the browser only.
Prompt
agent-browser open http://localhost:3000 && agent-browser screenshot --full --annotate -p browserbase Cloud Browser Run the session in a cloud browser provider.
Prompt
agent-browser -p browserbase open https://example.com "I already took a snapshot, just keep clicking"
Element refs become stale after any navigation or DOM change. Always re-snapshot before the next action.
"Save the auth state and share the screenshots freely"
Auth state, HAR files, and screenshots can contain sensitive session data and secrets. Review before sharing.
"Use cloud browser for all tasks"
Cloud providers (Browserbase, AgentCore) incur cost per session. Use them only when local browser is insufficient.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
agent-browser open http://localhost:3000 agent-browser snapshot -i -c agent-browser fill @e3 "user@example.com" && agent-browser click @e7 agent-browser screenshot --full --annotate agent-browser record start && agent-browser record stop agent-browser state save auth-state.json agent-browser --enable react-devtools open http://localhost:3000 && agent-browser react tree agent-browser -p browserbase open https://example.com agent-browser doctor --offline --quick Browser Evidence
Pattern
screenshots/*.png + videos/*.webm + HAR/trace/profile + QA report Outputs browser snapshots, screenshots, videos, HAR/trace/profile files, auth state when requested, and concise QA findings.
Quick Ref / Command
Engineer Kit
Media analysis and generation across Gemini, OpenRouter, MiniMax, document conversion, and media optimization routes.
Setup
Intent
Route
Model
Provider key first
Vision/audio/PDF analysis
Files for analysis, prompt for generation
Transcription
Chunk long media
Structured extraction
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
--task analyze Understand image/video/audio/PDF content
--task transcribe Create timestamped transcript
--task extract Extract structured data to JSON/CSV/markdown
--task generate Generate images via Google, OpenRouter, or MiniMax
--task generate-video Generate video via Veo or MiniMax
media optimizer Resize, compress, or split media before API call
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
python scripts/check_setup.py python scripts/gemini_batch_process.py --files screenshot.png --task analyze --prompt "Extract UI layout, visual hierarchy, and likely component states" python scripts/gemini_batch_process.py --files meeting.mp3 --task transcribe --prompt "Generate timestamped transcript with speaker labels" --format markdown --output meeting.md python scripts/gemini_batch_process.py --files invoice.pdf --task extract --prompt "Extract vendor, date, line items, totals as JSON" --format json --output invoice.json python scripts/gemini_batch_process.py --task generate --provider google --model gemini-3.1-flash-image-preview --prompt "Clean product mockup of a CLI dashboard" --aspect-ratio 16:9 --size 2K --num-images 2 python scripts/gemini_batch_process.py --task generate --provider openrouter --model google/gemini-3.1-flash-image-preview --prompt "Retro robot mascot for developer tooling" --output mascot.png python scripts/gemini_batch_process.py --task generate-video --model veo-3.1-generate-preview --prompt "Slow camera push across this interface mockup" --reference-images frame-start.png frame-end.png --resolution 1080p --aspect-ratio 16:9 python scripts/minimax_cli.py --task generate-speech --text "Welcome to the release walkthrough" --model speech-2.8-hd --voice English_Warm_Bestie --emotion happy --output-format mp3 python scripts/media_optimizer.py --input long-video.mp4 --split --chunk-duration 900 --output-dir ./chunks Media Artifacts
Pattern
docs/assets/*_generated_* + transcripts/extractions + optimized chunks Outputs generated images/video/audio/music, transcripts, structured extractions, document markdown, or optimized media chunks depending on route.
Quick Ref / Command
Engineer Kit
Technical and architecture consultation before implementation, grounded in context when needed.
Question
Context
Scout
Lenses
Consult before coding
Architecture decisions
Scout when context is thin
Technology choice
One clear position
Scalability tradeoffs
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
Question Direct technical consultation
Compare Evaluate two or more technical options
Plan review Critique an existing plan before coding
Context recovery Scout first when local context is missing
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:ask Should we split auth into a separate service or keep it in the monolith? /ck:ask Compare Postgres row-level security vs application-level tenant filters for this SaaS app. /ck:ask What is the simplest architecture for adding background job retries here? /ck:ask Review this plan for scaling websocket fanout without overbuilding. /ck:ask We need a migration path from REST to GraphQL. What should we avoid? Consultation Answer
Pattern
Architecture analysis + recommendation + tradeoffs + next actions Outputs a direct technical answer with recommendation, alternatives, risks, and validation actions.
Quick Ref / Command
Engineer Kit
STRIDE and OWASP security audit with optional red-team discovery and explicit fix mode.
Scope
Baseline
Audit
Red Team
Report-only unless --fix
STRIDE threat modeling
Never reveal raw secrets
OWASP code review
Critical blocks release
Secret handling
Core lanes from input to output, aligned with the command's real execution path.
Scope
Target + asset map
Audit
STRIDE, OWASP, secrets
Remediate
Fix + verify
Report
Findings + export
<scope> Focused Audit a specific glob or folder.
Prompt
/ck:security src/api/** --red-team Red Team Add adversarial attacker-perspective discovery loop.
Prompt
/ck:security --red-team src/auth/ --fix Auto-fix Allow code changes for accepted findings.
Prompt
/ck:security --fix src/api/** --iterations N Bounded Bound audit or fix loop by iteration count.
Prompt
/ck:security --red-team --iterations 3 "I found a vuln, fix it now"
Default route is report-only. Use --fix explicitly to enable remediation.
"Red team found nothing, we are secure"
Absence of findings is not proof of security. Check coverage and iteration count.
"Skip verify, the fix is obvious"
Every remediation must be verified. Obvious fixes can introduce new attack surfaces.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:security src/api/**/*.ts /ck:security full /ck:security full --red-team /ck:security src/ --red-team --iterations 20 /ck:security src/ --fix /ck:security src/ --fix --iterations 15 /ck:security full --red-team --fix Security Audit Artifacts
Pattern
security report + security-audit-results.tsv + coverage/fix summary Outputs ranked findings, evidence, remediation notes, TSV export, coverage summary, and fix verification when --fix is used.
Quick Ref / Command
Engineer Kit
Pack local or remote repositories into structured AI context with format, scope, token, and safety controls.
Target
Scope
Safety
Format
Scope before pack
Repository packing
Security warning must be resolved
Context shaping
Token budget is visible
Token budgeting
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
--style Select xml, markdown, plain, or json
--remote Pack a remote repository source
--include / -i Restrict files by glob filters
--remove-comments Reduce token count by stripping comments
--output / -o Write to a custom path
--copy / -c Copy generated pack to clipboard
--init Create reusable repomix config
--token-count-tree Show token-heavy file tree
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:repomix /ck:repomix packages/web /ck:repomix --style markdown /ck:repomix --remote https://github.com/org/repo /ck:repomix --include "src/**,docs/**" /ck:repomix --remove-comments /ck:repomix -o plans/context/auth-pack.md --style markdown /ck:repomix --copy /ck:repomix --init /ck:repomix --token-count-tree 200 /ck:repomix --no-gitignore --no-default-patterns /ck:repomix --no-security-check Repository Context Pack
Pattern
repomix-output.xml or custom output + repomix.config.json + token/security summary Outputs a structured repository pack, optional config/ignore files, token-count tree, and security warnings for review.
Quick Ref / Command
Engineer Kit
Generate llms.txt and optional full-context documentation indexes for LLM-friendly site discovery.
Source
Filter
Summarize
Full
Public docs only
llms.txt spec
No deploy side effects
Documentation indexing
Do not expose private config
URL/doc scanning
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
[path] Scan a local documentation path
--url <base> Use a public URL as source
--full Also generate full-context file
--output <path> Write index to explicit path
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:llms /ck:llms docs/ /ck:llms --url https://vividkit.dev/guides /ck:llms --full /ck:llms --output public/llms.txt /ck:llms --url https://vividkit.dev --output public/llms.txt LLM Documentation Index
Pattern
llms.txt + optional llms-full.txt Outputs a concise docs index and, when requested, a larger full-context file for LLM consumers.
Quick Ref / Command
Engineer Kit
Generate edge cases, failures, security scenarios, and QA matrices from features or source files.
Input
Lens
Decompose
Iterate
Report only
Edge-case discovery
Novelty matters
Failure analysis
Rotate after repeated dimensions
Threat scenarios
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
--iterations N Cap discovery loop length
--saturation Stop when new-value generation dries up
--domain Use software, product, business, security, or marketing lens
--focus Prioritize edge-cases, failures, security, or scale
--format Choose table, use-cases, test-scenarios, or threat-scenarios
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:scenario "User can reset password with email OTP" /ck:scenario src/auth/reset-password.ts /ck:scenario checkout flow --iterations 12 /ck:scenario checkout flow --saturation /ck:scenario onboarding --domain product /ck:scenario upload API --focus security /ck:scenario payment webhook --format threat-scenarios Scenario Discovery Report
Pattern
scenario report + severity summary + optional scenario-results.tsv Outputs categorized scenarios, severity summary, coverage matrix, composite score, and optional TSV for QA handoff.
Quick Ref / Command
Engineer Kit
Initialize, update, and summarize project documentation through a docs-only workflow.
Action
Scan
Route
Split
Docs-only workflow
Project documentation
Ask on no-args
README generation
Do not auto-init silently
Codebase summaries
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
init Create baseline project docs
update Sync existing docs to current code
summarize Create or refresh codebase summary
[no args] Ask which docs action to run
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:docs /ck:docs init /ck:docs update /ck:docs summarize /ck:docs init README.md docs/system-architecture.md /ck:docs update src/auth Documentation Artifacts
Pattern
README.md + docs/*.md + docs/codebase-summary.md Outputs initialized or refreshed documentation, codebase summary, and validation warnings when relevant.
Quick Ref / Command
Engineer Kit
Feature extraction and porting front door for comparing, copying, improving, or rewriting behavior from another repository.
Recon
Map
Analyze
Challenge
Understand before copy
Feature extraction
Challenge before plan
Cross-stack porting
Adapt instead of transplant
Dependency mapping
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
--compare Report only; no implementation plan
--copy Minimal transplant with compatibility checks
--improve Borrow behavior and replace anti-patterns
--port Idiomatic local-stack rewrite; default route
--fast Skip research/challenge for low-risk speed
--auto Full workflow with auto-approved gates
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:xia vercel/next.js "metadata handling" --compare /ck:xia owner/repo "command palette" --copy /ck:xia ../reference-app "billing checkout" --improve /ck:xia remix-run/react-router "nested route loaders" --port /ck:xia owner/repo "toast notification UX" --fast /ck:xia owner/repo "settings import flow" --auto Feature Porting Packet
Pattern
plans/reports/feature-comparison-<slug>.md or ./plans/<plan-dir>/plan.md + source/dependency/decision matrices Outputs source manifest, source anatomy, local map, dependency matrix, decision matrix, risk score, and either comparison recommendation or ck:cook handoff.
Quick Ref / Team orchestration
Parallel multi-session
Use it to spawn N independent Claude Code teammates in parallel — research from multiple angles, cook many files, review multiple focuses, or debug competing hypotheses.
Invoke
Pre-flight
Spawn N
Synth + close
Four lanes: setup pre-flight, parallel spawn, event-driven coordination, then synthesize and close.
Setup
Invoke + pre-flight check
Spawn
Derive N + spawn in parallel
Coordinate
Hooks + teammate DM
Close
Synthesize + shutdown
Pick a template by need. Each one has its own default N, behaviour, and artifact.
research Default N: 3 Research from N angles
Sample prompt
/ck:team research Compare auth strategies for our SaaS app Use when
Architecture decisions, technology evaluation, multi-angle investigation.
Output
research-summary-<slug>.md — exec summary, comparative analysis, recommendations.
cook Default N: 4 devs + 1 tester Cook with file-owned devs
Sample prompt
/ck:team cook plans/.../plan.md --devs 4 --worktree Use when
Multi-file feature implementation with parallel devs in isolated worktrees.
Output
Merged branches via git merge --no-ff + MANDATORY docs sync eval + test results.
review Default N: 3 Review N focuses
Sample prompt
/ck:team review src/api --reviewers 3 Use when
Pre-merge review with security, performance, and test-coverage lanes in parallel.
Output
review-<slug>.md — severity-dedupe (CRITICAL / IMPORTANT / MODERATE) + action items.
debug Default N: 3 Debug competing hypotheses
Sample prompt
/ck:team debug "Webhook returns 500 intermittently" --debuggers 3 Use when
Hard-to-reproduce bugs where you want adversarial disproof to converge on root cause.
Output
debug-<slug>.md — root cause + evidence chain + disproven hypotheses.
Per-Template Report
Lead synthesizes the report after every teammate finishes. Fixed location at plans/reports/.
research-summary / cook merge+docs / review-<slug> / debug-<slug>.md These five rules apply to every template — violating them breaks team execution.
Quick Ref / Visual utility
Read-only · never modifies code
View files or generate visual explanations, diagrams, and slide decks — in the browser or as a self-contained HTML page. A read/visualize utility that never modifies code.
Input
Route
Generate
Output
One input (file path or generate flag + topic) runs through four stages: receive, route, generate, then emit to the browser or a self-contained HTML page.
Receive
File path or generate flag + topic
Route + generate
Pick a shape, build prose + ASCII + Mermaid
Emit
Live browser or self-contained HTML
View (no flag) takes a path to read/walk through a file. Eight flags in three groups: Generate picks an output shape from a topic; --html wraps any generate flag into a standalone page; the Review group requires --html.
View · no flag
Read an existing file/dir — plans in novel UI
<file.md> View one markdown file (plan, phase, doc) in the novel-reader UI — Mermaid renders live.
Sample prompt
/ck:preview plans/.../plan.md <dir/> Pass a folder to browse every doc inside — e.g. a whole plan folder (plan.md + all phase files).
Sample prompt
/ck:preview plans/260527-.../ <path> View reads the file as-is. Contrast with generate flags (--explain / --diagram / --slides / --ascii): they take a topic in plain words and build a new visual — not a path.
Sample prompt
/ck:preview src/auth/middleware.ts Generate
Pick one output shape from a topic
--explain Visual explanation of code or a concept — narrative + ASCII + Mermaid diagrams
Sample prompt
/ck:preview --explain How does the auth middleware chain work in this repo --diagram Architecture and data-flow diagrams
Sample prompt
/ck:preview --diagram Data flow from webhook to notification queue --slides Step-by-step walkthrough as a slide deck
Sample prompt
/ck:preview --slides "onboarding flow" --ascii Terminal-friendly ASCII diagram (no browser needed)
Sample prompt
/ck:preview --ascii "folder structure" Output
Composes with any generate flag
--html Self-contained HTML page — composes with any generate flag, opens directly in browser
Sample prompt
/ck:preview --html --diagram "DB schema" Review · implies --html
Diff, plan-vs-code, and recap views
--diff [ref] Visual diff review of changes (requires --html)
Sample prompt
/ck:preview --diff HEAD~3 --plan-review [plan-file] Compare a plan file against the actual codebase — implies --html. Omit the path to use the active plan.
Sample prompt
/ck:preview --plan-review plans/.../plan.md Omit path → active plan
/ck:preview --plan-review --recap [timeframe] Project context snapshot over a timeframe (requires --html)
Sample prompt
/ck:preview --recap "last week" Which modes need a local server, which are self-contained.
Local server
markdown-novel-viewer
Self-contained
No server — opens in browser
/ck:preview --stop {slug}.md (browser) · {slug}.html (self-contained){plan_dir}/visuals/ plans/visuals/ With an active plan, visuals live inside that plan folder. No plan → falls back to plans/visuals/.
Five rules that shape how preview behaves — always safe, always shareable.
Quick Ref / Command
Engineer Kit
Target a real Google Chrome profile — account, cookies, workspace, tenant — for browser automation through Chrome DevTools MCP, with profile discovery, bridge diagnostics, and URL-anchor tab selection.
Decide
Resolve Profile
Bridge
Open
Use only when real profile state matters
Real Chrome profile targeting
Resolve keys by account, not directory
Chrome DevTools MCP bridge
doctor is a heuristic — confirm with a live probe
Profile discovery
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
list Show resolvable profile keys
setup Map profiles to stable keys (per-machine)
doctor Static bridge-readiness heuristic
open --json Open URL in profile; emit bind selector
--force Open when CLI cannot classify a working bridge
--no-activate Open in background, return focus (macOS)
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
chrome-profile open --json work "https://github.com/org/repo/pulls" chrome-profile list chrome-profile setup --yes chrome-profile doctor chrome-profile open --json --no-activate work "https://example.com" chrome-profile open --json work "https://example.com" --force Bound Profile Tab + Open Payload
Pattern
open --json: { bind_selector, opened_url, profile_dir, profile_key, profile_marker } Emits machine-readable binding data so the agent selects the exact profile tab from a flat MCP page list, then operates (snapshot/click/evaluate/screenshot) on the user's real session.
Quick Ref / Command
Engineer Kit
Set coding experience level for tailored output. Use for adjusting explanation depth, code complexity, and response format to user expertise.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:coding-level beginner /ck:coding-level intermediate /ck:coding-level expert Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Conversion copywriting formulas, headline templates, email copy patterns, landing page structures, CTA optimization, and writing style extraction. Activate for writing high-converting copy, crafting headlines, email campaigns, landing pages, or applying custom writing styles from assets/writing-styles/ directory.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:copywriting headline formula "VividKit early access launch" /ck:copywriting landing page "ClaudeKit workflow visualizer feature" /ck:copywriting email "Reactivate beta users who signed up 30 days ago" Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Work with MongoDB (document database, BSON documents, aggregation pipelines, Atlas cloud) and PostgreSQL (relational database, SQL queries, psql CLI, pgAdmin). Use when designing database schemas, writing queries and aggregations, optimizing indexes for performance, performing database migrations, configuring replication and sharding, implementing backup and restore strategies, managing database users and permissions, analyzing query performance, or administering production databases.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
schema/query Design schemas, write queries, or optimize indexes
migration Write and validate database migration scripts
admin/ops Configure replication, backup, users, or performance tuning
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:databases design schema for a multi-tenant SaaS with user, org, and billing tables in PostgreSQL /ck:databases optimize this slow PostgreSQL query that times out on 5M rows /ck:databases write MongoDB aggregation pipeline to group orders by user and sum revenue per month Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Deploy and manage cloud infrastructure on Cloudflare (Workers, R2, D1, KV, Pages, Durable Objects, Browser Rendering), Docker containers, and Google Cloud Platform (Compute Engine, GKE, Cloud Run, App Engine, Cloud Storage). Use when deploying serverless functions to the edge, configuring edge computing solutions, managing Docker containers and images, setting up CI/CD pipelines, optimizing cloud infrastructure costs, implementing global caching strategies, working with cloud databases, or building cloud-native applications.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
deploy Deploy to edge, container, or cloud platform
CI/CD Set up or fix CI/CD pipelines and automation
infra/ops Manage infrastructure, scaling, or cost optimization
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:devops deploy Edge API to Cloudflare Workers with KV storage and D1 database /ck:devops containerize the app with Docker Compose, Nginx reverse proxy, and health checks /ck:devops deploy to Google Kubernetes Engine with autoscaling and Cloud Run fallback Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:find-skills Is there a skill that can generate images? /ck:find-skills What skills are available for marketing? /ck:find-skills How do I create a Mermaid architecture diagram? Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Frontend development guidelines for React/TypeScript applications. Modern patterns including Suspense, lazy loading, useSuspenseQuery, file organization with features directory, MUI v7 styling, TanStack Router, performance optimization, and TypeScript best practices. Use when creating components, pages, features, fetching data, styling, routing, or working with frontend code.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
component Build or refactor a React component with types and tests
state/data Wire up state management, queries, or data fetching
performance Audit and fix React performance issues
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:frontend-development Build a reusable Pagination component with TypeScript, accessible keyboard nav, and Tailwind /ck:frontend-development Audit and fix React performance issues in the data table — too many re-renders /ck:frontend-development Add Zustand state management for the cart without prop drilling across 5 components Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Semantic code analysis with GitLab Knowledge Graph. Use for go-to-definition, find-usages, impact analysis, architecture visualization. Supports Ruby, Java, Kotlin, Python, TypeScript/JavaScript.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:gkg go-to-definition AuthService /ck:gkg find-usages useCurrentUser /ck:gkg search "authentication token refresh logic" Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Build AI agents with Google ADK Python. Multi-agent systems, tool integration, workflow orchestration.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
single agent Build a single conversational agent with tools and memory
multi-agent Orchestrate planner and specialist sub-agents
streaming Add real-time token streaming output to an agent
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:google-adk-python Build a customer support agent with tool calling and session memory in Python ADK /ck:google-adk-python Create a multi-agent pipeline where a planner routes tasks to specialized sub-agents /ck:google-adk-python Add streaming output to the research agent for real-time token delivery Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
💡 Write some journal entries.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:journal Document the decisions made in this session for the auth refactor /ck:journal Write a post-ship journal for the webhook integration we just deployed /ck:journal Log the technical debt we are accepting with the current pagination hack Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Autonomous iterative optimization loop — run N iterations against a mechanical metric, learn from git history, auto-keep/discard changes. Use for improving measurable metrics (coverage, performance, bundle size, etc.) through repeated experimentation.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:loop Goal: branch coverage >80 | Scope: src/**/*.ts | Verify: npm run coverage:score | Iterations: 8 /ck:loop Goal: p95 response time <150ms | Scope: src/api/search.ts | Verify: npm run bench | Iterations: 5 /ck:loop Goal: Lighthouse a11y score >95 | Scope: src/components/ | Verify: npm run lighthouse:a11y | Iterations: 6 Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
View markdown files with calm, book-like reading experience. Background HTTP server for rendering markdown.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
default (open) Open and render a markdown file in book-like reading view
--background Start background HTTP server for persistent markdown viewing
--stop Stop the background markdown viewer server
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:markdown-novel-viewer Open the RFC for the new authentication system for reading /ck:markdown-novel-viewer Open plans/phase-02-auth-implementation.md for review /ck:markdown-novel-viewer Read the researcher-01-report.md from the plans folder Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
new server Scaffold a new MCP server with tool definitions and transport
add tool Add new tool handlers to an existing MCP server
convert Convert existing scripts or APIs into MCP tool endpoints
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:mcp-builder Build an MCP server exposing file search and grep tools over HTTP transport /ck:mcp-builder Add a code-execution tool to the existing MCP server in src/mcp-server/ /ck:mcp-builder Convert the scripts/analysis.py script into an MCP tool endpoint Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Process multimedia files with FFmpeg (video/audio encoding, conversion, streaming, filtering, hardware acceleration), ImageMagick (image manipulation, format conversion, batch processing, effects, composition), and RMBG (AI-powered background removal). Use when converting media formats, encoding videos with specific codecs (H.264, H.265, VP9), resizing/cropping images, removing backgrounds from images, extracting audio from video, applying filters and effects, optimizing file sizes, creating streaming manifests (HLS/DASH), generating thumbnails, batch processing images, creating composite images, or implementing media processing pipelines. Supports 100+ formats, hardware acceleration (NVENC, QSV), and complex filtergraphs.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
video (FFmpeg) Encode, convert, trim, or compress video files
image (ImageMagick) Resize, convert, composite, or batch process images
background removal AI-powered background removal from images via RMBG
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:media-processing Compress the demo.mp4 to under 10MB for web delivery using FFmpeg /ck:media-processing Resize all images in assets/products/ to 800x800 WebP with ImageMagick /ck:media-processing Split the 2-hour podcast.mp3 into 15-minute chunks for transcription Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Create diagrams and visualizations using Mermaid.js v11 syntax. Use when generating flowcharts, sequence diagrams, class diagrams, state diagrams, ER diagrams, Gantt charts, user journeys, timelines, architecture diagrams, or any of 24+ diagram types. Supports JavaScript API integration, CLI rendering to SVG/PNG/PDF, theming, configuration, and accessibility features. Essential for documentation, technical diagrams, project planning, system architecture, and visual communication.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
flowchart/sequence Create flowcharts, sequence, or state diagrams
entity/ER Model data structures with ER or class diagrams
architecture Generate C4 container or architecture diagrams
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:mermaidjs-v11 Draw a flowchart for the user authentication login flow with error paths /ck:mermaidjs-v11 Create a sequence diagram for the webhook delivery retry mechanism /ck:mermaidjs-v11 Generate a C4 container diagram for the microservices backend Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Build and maintain Mintlify documentation sites. Covers docs.json, MDX components, navigation, page frontmatter, theming, OpenAPI/AsyncAPI, AI docs assets such as llms.txt and skill.md, deployment targets, and local validation CLI commands.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:mintlify init docs site for the ClaudeKit API with navigation, landing page, and quickstart /ck:mintlify Add API reference pages for all REST endpoints with request/response examples /ck:mintlify deploy the docs site to Mintlify hosting and configure the custom domain Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Build mobile apps with React Native, Flutter, Swift/SwiftUI, Kotlin/Jetpack Compose. Use for iOS/Android, mobile UX, performance optimization, offline-first, app store deployment.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:mobile-development Build a React Native onboarding flow with 3 screens, animations, and AsyncStorage /ck:mobile-development Create a Flutter reusable ProductCard widget with hero animation and responsive layout /ck:mobile-development Integrate push notifications using Firebase Cloud Messaging for iOS and Android Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Integrate payments with SePay (VietQR), Polar (SaaS subscriptions), Stripe (global payments). Use for checkout, webhooks, QR codes, subscriptions, currency conversion, multi-provider order management, commission systems.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:payment-integration Add Stripe Checkout for one-time payments with webhook handling and payment confirmation /ck:payment-integration Set up Stripe subscriptions with monthly/annual plans, trial period, and customer portal /ck:payment-integration Configure Polar.sh for open-source sponsorship and one-time product purchases Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:problem-solving Why is the checkout conversion rate dropping after the last deploy? /ck:problem-solving Should we use server-side sessions or JWTs for auth in this SaaS app? /ck:problem-solving We need to support 100k concurrent users within 3 months with the current team of 4 Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Track progress, update plan statuses, manage Claude Tasks, generate reports, coordinate docs updates. Use for project oversight, status checks, plan completion, task hydration, cross-session continuity.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:project-management Create a 2-week sprint plan for the auth refactor with story points and dependencies /ck:project-management Generate a weekly status report for the Q2 roadmap progress /ck:project-management Build a risk register for the database migration project Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Apply React and Next.js performance optimization patterns from Vercel Engineering. Use for component optimization, rendering performance, bundle analysis.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:react-best-practices Review these components for unnecessary re-renders and missing memoization /ck:react-best-practices Refactor the authentication logic into a custom useAuth hook following React best practices /ck:react-best-practices Design the global state architecture for a multi-step form with validation Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Best practices for Remotion - Video creation in React
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
composition Create a new Remotion composition with timeline and props
animation Add motion, easing, and Spring animations to scenes
export Configure render pipeline and export final video
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:remotion Create a 5-second product intro animation with logo reveal and tagline for VividKit /ck:remotion Build a bar chart race animation showing monthly user growth over 12 months /ck:remotion Generate a video walkthrough of the ClaudeKit guide slides with voiceover timing Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Turn HTML/CSS/JS templates into real local MP4 videos through headless Chromium and ffmpeg, with template discovery, Studio editing, and ffprobe-verified renders.
Brief
Setup
Discover
Build
Pin the brief before creating
HTML/CSS/JS video templates
Prefer binary, never vendor the engine
Template discovery
doctor passes before render
Studio editing
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
doctor Diagnostics for Chromium, ffmpeg, engines
search-templates Rank templates by intent and aspect
project-set-var(s) Set template variables by CLI
studio Interactive editor for empty-schema templates
project-render Render MP4 to explicit output path
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:html-video short product promo for a developer tool, 16:9, 20s html_video doctor && html_video list-engines html_video search-templates --intent "short product promo" --aspect 16:9 --top 5 html_video project-create --name "Promo" --intent "..." --aspect 16:9 html_video studio --port 3071 html_video project-render <id> --output ./assets/videos/promo.mp4 --stream-progress /ck:html-video https://github.com/org/repo summary video, 16:9 Verified Local MP4 + Project
Pattern
assets/videos/<slug>.mp4 (or plans/<plan>/visuals/<slug>.mp4) + project dir + ffprobe verification Outputs a verified local MP4 and the html-video project state; finished exports in assets/videos, proof artifacts in plans/<slug>/visuals, scratch in tmp/html-video. Large MP4 files are not committed unless requested.
Quick Ref / Command
Engineer Kit
Research technical solutions, analyze architectures, gather requirements thoroughly. Use for technology evaluation, best practices research, solution design, scalability/security/maintainability analysis.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:research Compare Astro vs Next.js for a documentation site with heavy static content /ck:research What are the top developer tools pain points in 2025 for AI-assisted coding? /ck:research Find the best TypeScript ORM for a multi-tenant PostgreSQL SaaS app Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Fast codebase scouting via parallel Explore agents. Locates files, symbols, and context before planning or implementation.
Invoke
Context
Dispatch
Search
Scope before searching
File discovery
Read-only, never edit
Symbol search
Parallel agents for speed
Cross-file context gathering
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
file discovery Find files matching pattern or description
symbol search Find where a function, type, or constant is defined
task context Gather all relevant files before planning
"Scout will edit the files it finds"
Scout is strictly read-only. It locates and reports. Edits belong to the implementation phase via ck:cook or manual work.
"One broad search will find everything"
Parallel scoped agents are faster and more accurate than one broad search. Break large targets into focused sub-searches.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:scout Find all API route files and auth middleware /ck:scout Where is useAuthSession defined and how is it used? /ck:scout Gather context for adding Stripe webhook support Scout Report
Pattern
file paths + symbol locations + context notes + skipped checks Returns file paths, symbol definitions, usage patterns, relevant context, and explicit notes on unavailable data.
Quick Ref / Command
Engineer Kit
Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification. Use for complex problem decomposition, adaptive planning, analysis needing course correction, problems with unclear scope, multi-step solutions, and hypothesis-driven work.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:sequential-thinking Plan the migration from REST to GraphQL for the existing API with zero downtime /ck:sequential-thinking Trace the root cause of the memory leak in the WebSocket connection pool /ck:sequential-thinking Should we adopt microservices for the billing module or keep it in the monolith? Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Write GLSL fragment shaders for procedural graphics. Topics: shapes (SDF), patterns, noise (Perlin/simplex/cellular), fBm, colors (HSB/RGB), matrices, gradients, animations. Use for generative art, textures, visual effects, WebGL, Three.js shaders.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:shader Write a GLSL fragment shader for an animated noise-based gradient background /ck:shader Create a WebGL particle system shader for 10,000 particles with gravity and friction /ck:shader Implement a chromatic aberration post-processing effect for a Three.js scene Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Build Shopify applications, extensions, and themes using GraphQL/REST APIs, Shopify CLI, Polaris UI components, and Liquid templating. Capabilities include app development with OAuth authentication, checkout UI extensions for customizing checkout flow, admin UI extensions for dashboard integration, POS extensions for retail, theme development with Liquid, webhook management, billing API integration, product/order/customer management. Use when building Shopify apps, implementing checkout customizations, creating admin interfaces, developing themes, integrating payment processing, managing store data via APIs, or extending Shopify functionality.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
theme Develop or customise Shopify Liquid theme sections
app/extension Build App Bridge or Checkout UI extensions
API integration Integrate Shopify REST/GraphQL API for store data
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:shopify Create a Shopify theme section for product recommendations with Liquid and Polaris styling /ck:shopify Build a Shopify App Block extension for displaying trust badges on product pages /ck:shopify Add a gift message input to the Shopify checkout using Checkout UI Extensions Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Create stunning self-contained HTML pages to showcase work. Use for demos, visual presentations, interactive showcases.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:tanstack Add TanStack Query for the user profile data with optimistic updates and error boundaries /ck:tanstack Build a multi-step checkout form with TanStack Form, validation, and field-level errors /ck:tanstack Migrate the existing React Router setup to TanStack Router with type-safe routes Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Create or update Claude skills optimized for Skillmark benchmarks — new skills, scripts, references, and capability extensions.
Invoke
Context
Scaffold
Optimize
Benchmark-driven
Skill authoring
Clean skill structure
Skillmark benchmarks
Routing accuracy
SKILL.md structure
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:skill-creator Create a new skill called "api-tester" that generates Postman collections from OpenAPI specs /ck:skill-creator Optimize the /ck:debug skill to improve its Skillmark routing accuracy score /ck:skill-creator Add a Python analysis script and reference data to the /ck:security skill Workflow Output
Pattern
Skill artifact path + Skillmark score + activation test result The guide models skill creation as: define, scaffold, optimize for benchmark, validate activation.
Quick Ref / Command
Engineer Kit
AI design generation with Google Stitch — text prompt → UI prototype → Tailwind/HTML export → design-to-code pipeline.
Invoke
Context
Generate
Export
Prompt clarity
AI design generation
Brand consistency
Tailwind export
Export fidelity
Prototyping
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:stitch Generate a SaaS landing page with hero section, features grid, and pricing table /ck:stitch Create an admin dashboard with sidebar navigation, stats cards, and data table /ck:stitch Design a mobile-first multi-step onboarding form with progress indicator Workflow Output
Pattern
Design preview + Tailwind/HTML export path + DESIGN.md + validation summary The guide models Stitch as a prompt-to-code pipeline: describe, generate, export, validate.
Quick Ref / Command
Engineer Kit
Build with TanStack Start (full-stack React), TanStack Form (headless forms), and TanStack AI (streaming/chat).
Invoke
Context
Route
Execute
Type safety first
TanStack Start
Server-client boundary
TanStack Form
Headless patterns
TanStack AI
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:tanstack Create a new /dashboard route with loader that fetches user stats via server function /ck:tanstack Build a registration form with email/password validation using TanStack Form /ck:tanstack Add an AI chat panel using TanStack AI with streaming responses Workflow Output
Pattern
Route/form/chat artifact + type validation + integration test summary The guide models TanStack workflows as: route the sub-package, scaffold, validate types, test integration.
Quick Ref / Command
Engineer Kit
Generate publish-grade SVG+PNG technical diagrams — architecture, data flow, flowchart, sequence, agent/memory, or concept maps — across 8 visual styles, rendered via rsvg-convert.
Classify
Extract
Style
Write SVG
Classify before drawing
Architecture diagrams
Semantic arrows + legend
Data flow
Python list SVG method
Sequence
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
architecture Architecture diagram
data flow Data flow diagram
flowchart Flowchart / process
sequence Sequence diagram
agent/memory Agent + memory map
concept map Mind / concept map
--style N Visual style 1-8
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:tech-graph architecture diagram for the microservices backend with CDN and data layers /ck:tech-graph data flow for the OAuth login from browser to API to database /ck:tech-graph flowchart for the checkout decision and retry process /ck:tech-graph sequence diagram of the payment webhook handshake /ck:tech-graph agent memory architecture with working, episodic, and long-term tiers /ck:tech-graph concept map for the ClaudeKit skill ecosystem /ck:tech-graph architecture diagram --style 3 /ck:tech-graph ER diagram for the orders schema --output ./docs/orders-er.svg Diagram Artifacts
Pattern
./[derived-name].svg + ./[derived-name].png (1920px), or --output path Produces a validated SVG source and a 2x-retina PNG export per diagram, with a legend when 2+ arrow types are used.
Quick Ref / Command
Engineer Kit
Build 3D web apps with Three.js (WebGL/WebGPU). 556 searchable examples, 60 API classes, 20 use cases. Actions: create 3D scene, load model, add animation, implement physics, build VR/XR. Topics: GLTF loader, PBR materials, particle effects, shadows, post-processing, compute shaders, TSL. Integrations: WebGPU, physics engines, spatial audio.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
scene setup Create a Three.js scene with camera, lighting, and geometry
3D model/shader Load GLTF models or write custom GLSL shaders
interactivity Add orbit controls, raycasting, scroll-driven camera, or physics
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:threejs Create a Three.js hero section with rotating particle field and scroll-driven camera animation /ck:threejs Build a 3D product model viewer with orbit controls and environment lighting /ck:threejs Add a custom GLSL water ripple shader effect to the landing page hero mesh Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Create beautiful, accessible user interfaces with shadcn/ui components (built on Radix UI + Tailwind), Tailwind CSS utility-first styling, and canvas-based visual designs. Use when building user interfaces, implementing design systems, creating responsive layouts, adding accessible components (dialogs, dropdowns, forms, tables), customizing themes and colors, implementing dark mode, generating visual designs and posters, or establishing consistent styling patterns across applications.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
design system Set up Tailwind tokens, theme, and brand config
shadcn component Install and customise a shadcn/ui component
dark mode Implement dark mode with CSS variables and system preference
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:ui-styling Set up Tailwind design tokens for colors, typography, spacing aligned to the brand guide /ck:ui-styling Add the shadcn DataTable component with sorting, filtering, and pagination /ck:ui-styling Implement dark mode toggle with Tailwind and CSS variables supporting system preference Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
UI/UX design intelligence for web and mobile. Includes 50+ styles, 161 color palettes, 57 font pairings, 161 product types, 99 UX guidelines, and 25 chart types across 10 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui, and HTML/CSS). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, and check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, and mobile app. Elements: button, modal, navbar, sidebar, card, table, form, and chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, and flat design. Topics: color systems, accessibility, animation, layout, typography, font pairing, spacing, interaction states, shadow, and gradient. Integrations: shadcn/ui MCP for component search and examples.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
design direction Set visual direction: style, palette, typography, layout
visual audit Audit existing UI for inconsistencies, a11y, UX issues
motion design Specify micro-interactions, transitions, and animation system
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:ui-ux-pro-max Set design direction for the new settings page: minimal, high-density, dark-first /ck:ui-ux-pro-max Audit the current dashboard for visual inconsistencies and design anti-patterns /ck:ui-ux-pro-max Design the micro-interaction system for button states, toasts, and drawer transitions Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
💡 Review recent changes and wrap up the work
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:watzup Generate a handoff summary for this session before switching to a new chat /ck:watzup Write an EOD summary of today's development work /ck:watzup Create a project context snapshot for onboarding a new team member Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:web-design-guidelines Audit the current navigation component for WCAG 2.1 AA compliance /ck:web-design-guidelines Review the onboarding form UX for friction points and cognitive load /ck:web-design-guidelines Audit button styles across all pages for design system consistency Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Build modern full-stack web applications with Next.js (App Router, Server Components, RSC, PPR, SSR, SSG, ISR), Turborepo (monorepo management, task pipelines, remote caching, parallel execution), and RemixIcon (3100+ SVG icons in outlined/filled styles). Use when creating React applications, implementing server-side rendering, setting up monorepos with multiple packages, optimizing build performance and caching strategies, adding icon libraries, managing shared dependencies, or working with TypeScript full-stack projects.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Next.js Build Next.js App Router pages with RSC, server actions, and ISR
Astro Create Astro pages with component islands and integrations
monorepo (Turborepo) Set up or optimise a Turborepo monorepo with shared packages
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:web-frameworks Build a Next.js App Router page with RSC, server actions, and Suspense loading /ck:web-frameworks Create an Astro page with a React island for an interactive search component /ck:web-frameworks Implement a TanStack Start page with loader, mutation, and optimistic UI Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Web testing strategy and runner: Playwright E2E, Vitest unit/integration, k6 load, visual regression, a11y, and Core Web Vitals.
Strategy
Setup
Write Tests
Execute
Strategy before runner
Playwright E2E and visual
Real browser for E2E
Vitest unit and integration
Fix flakiness, do not mask it
k6 load testing
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
"Flaky tests can just be retried automatically"
Flakiness must be diagnosed and fixed, not masked by retries. Retries hide real bugs and inflate CI time.
"Visual tests always need a new baseline screenshot"
Only update visual baselines when the change is intentional and approved. Blindly updating baselines defeats the purpose of visual regression testing.
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:web-testing Write Playwright E2E tests for the checkout flow including mobile and a11y checks /ck:web-testing Add Vitest unit tests for the useAuthSession hook covering token refresh logic /ck:web-testing Create a k6 load test for the /api/search endpoint targeting p95 under 200ms at 500 VUs Test Suite + QA Report
Pattern
test specs + runner output + coverage + failures + performance summary Outputs test specs, runner results, coverage numbers, failure root causes, performance findings, and recommended next steps.
Quick Ref / Command
Engineer Kit
Create isolated git worktree for parallel development
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:worktree Create an isolated worktree for the feature/auth-refactor branch /ck:worktree list /ck:worktree remove feature/auth-refactor Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
>-
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/excalidraw Draw a system architecture sketch for the ClaudeKit multi-agent workflow /excalidraw Create a low-fidelity wireframe for the new dashboard navigation layout /excalidraw Map the user onboarding decision flowchart from signup to first workflow run Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Plans dashboard server with progress tracking and timeline visualization.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:plans-kanban Show the current plan phases as a Kanban board /ck:plans-kanban Mark phase-02 tasks as completed and move to phase-03 /ck:plans-kanban Show all blocked tasks across the active plan Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Engineer Kit
Organize files, directories, and content structure in any project. Use when creating files, determining output paths, organizing existing assets, or standardizing project layout.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ck:project-organization Design a folder structure for a monorepo with web, mobile, and API packages /ck:project-organization Define file naming conventions for the frontend TypeScript codebase /ck:project-organization Audit package.json for duplicate, outdated, and unused dependencies Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Customer persona management: create, analyze, update, and list market-validated ICP profiles.
Action
Gather
Qualify
Validate
Five dimensions before create
ICP profiling
Market validation for new personas
Audience segmentation
Existing profile validation before update
Market validation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
create Create a new persona from five dimensions
analyze Analyze audience data and segments
update [name] Load, revise, and validate existing persona
list List saved personas
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:persona create "AI-native solo developer using ClaudeKit daily" /ckm:persona analyze assets/audience/beta-users.csv /ckm:persona update solo-dev-founder /ckm:persona list ICP Profile
Pattern
assets/leads/icp-profiles/{persona}.md Outputs a reusable persona/ICP profile for campaign, SEO, writing, and email workflows.
Quick Ref / Command
Marketing Kit
Campaign planning, execution, status tracking, analysis, and email coordination across marketing channels.
Action
Context
Plan
Funnel
Action-specific routing
Campaign briefs
Campaign files are the source for status/analyze
Funnel strategy
Separate strategy from diagnostics
Budget/timeline planning
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
create Comprehensive campaign creation
status Read campaign files and display progress
analyze Performance analysis and diagnostics
email Email campaign coordination
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:campaign:create "Launch VividKit beta to ClaudeKit users" /ckm:campaign:status campaigns/vividkit-beta /ckm:campaign:analyze campaigns/vividkit-beta /ckm:campaign:email "Reactivate waitlist users for beta invite" Campaign Assets
Pattern
assets/campaigns/{date}-{slug}/... Outputs campaign briefs, creatives, reports, and diagnostics depending on action.
Quick Ref / Command
Marketing Kit
Marketing Kit writing router for copy, blog, CRO, formula, audit, and publish-ready content.
Route
Context
Research
Write
One selected reference controls the workflow
Creative copywriting
Audit/publish gates protect generated content
SEO articles
Visuals only after content direction is clear
YouTube-to-blog
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
fast Quick creative copy
good Research + plan + write + optional design
blog SEO blog with audit/publish gate
publish Audit, auto-fix, publish-ready output
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:write:audit drafts/landing-page.md /ckm:write:blog "How ClaudeKit plan/cook workflows work" /ckm:write:blog-youtube https://youtube.com/watch?v=VIDEO_ID /ckm:write:cro "Improve signup section copy for VividKit early access" /ckm:write:enhance drafts/hero-copy.md /ckm:write:fast "3 headline options for the launch banner" /ckm:write:formula AIDA "VividKit early access signup" /ckm:write:good "Landing page copy for VividKit desktop beta" /ckm:write:publish drafts/claudekit-workflows.md Reference-defined Output
Pattern
assets/articles/... | content/blog/... | assets/copy/... | {path}-published.md Concrete save path depends on subcommand; lighter flows may return copy inline.
Quick Ref / Command
Marketing Kit
Unified marketing design router for brand, tokens, UI styling, logo, CIP, slides, banners, social photos, icons, and posters.
Input
Route
Reference
Gate
Route by space arguments
Logo generation
Load only needed references
CIP deliverables
Research before generation
Social photo export
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
logo Logo generation and preview gate
banner Ask requirements, build, export exact PNG
social photos Concept approval, HTML/CSS, screenshot export
poster Model-agnostic prompt output
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:design brand "Identity direction for VividKit Desktop" /ckm:design design-system "Tokens for a documentation dashboard" /ckm:design ui "Polish the onboarding settings screen" /ckm:design logo "Minimal mark for an AI developer tools app" /ckm:design cip "Business card and letterhead mockups for VividKit" /ckm:design slides "Investor update deck for VividKit beta" /ckm:design banner "Product Hunt launch banner for VividKit" /ckm:design social photos "LinkedIn and X launch images for ClaudeKit workflows" /ckm:design icon "Command palette icon set" /ckm:design poster "Facebook infographic for ClaudeKit workflow" Design Assets + Report
Pattern
route-specific assets + plans/reports/<design-report>.md Outputs logo PNGs, CIP mockups, slide HTML, exact-size banners/social exports, SVG icons, or poster prompts.
Quick Ref / Command
Marketing Kit
SEO audits, keyword research, pSEO templates, on-page optimization, and schema generation with explicit data-source gates.
Input
Route
Data
Agents
No invented metrics
Technical SEO audit
Credential-aware data use
Keyword research
Validate generated SEO assets
Programmatic SEO
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
audit 0-100 technical/content audit with data-source list
keywords Keyword research with availability-aware metrics
pseo Programmatic SEO templates and sample validation
schema JSON-LD generation and validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:seo:audit https://vividkit.dev/guides/how-ck-works /ckm:seo:keywords "ClaudeKit workflows" /ckm:seo:pseo "ClaudeKit command pages by skill category" /ckm:seo:optimize content/how-ck-works.md /ckm:seo:schema https://vividkit.dev/guides/how-ck-works SEO Assets
Pattern
assets/seo/audits | assets/seo/keywords | assets/attraction/pseo-templates | assets/seo/schemas Outputs scored audits, keyword sets, pSEO templates/samples, and validated schema files.
Quick Ref / Command
Marketing Kit
Email content, automation flows, drip sequences, subject-line variants, deliverability, and campaign copy.
Type
Context
Route
Structure
Audience/message/CTA first
Automation flows
Subject variants matter
Drip sequences
Flow structure before copy
Subject lines
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
flow Automation flow with branches and implementation notes
sequence Drip sequence with full copy
newsletter/cold/launch/nurture Single or campaign email content
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:email:flow "Onboard new ClaudeKit users after signup" /ckm:email:sequence "5-email launch sequence for waitlist" /ckm:email:newsletter "June VividKit product update" /ckm:email:cold "Invite OSS maintainers to try VividKit" /ckm:email:followup "Follow up after beta invite click" /ckm:email:launch "Announce VividKit Desktop beta" /ckm:email:nurture "Educate ClaudeKit users on visual workflows" /ckm:email:welcome "Welcome new early access subscribers" /ckm:email:winback "Bring inactive beta users back" Email Assets
Pattern
assets/copy/emails/... or assets/emails/flows/... Outputs single emails, flow docs, drip sequences, subject variants, preview text, body copy, CTAs, and platform notes.
Quick Ref / Command
Marketing Kit
Video marketing pipeline for scripts, storyboards, AI video generation, platform optimization, thumbnails, and repurposing.
Route
Brief
Script
Storyboard
Route to one subcommand
Video scripts
Platform specs shape format
Storyboards
Review each production stage
AI video generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Close
Report, handoff, artifact
create Full AI video generation pipeline
script-create Production-ready video script
storyboard-create Storyboard with frame prompts/assets
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:video:create "90-second VividKit product walkthrough" /ckm:video:script-create "90-second VividKit product walkthrough" /ckm:video:storyboard-create scripts/vividkit-walkthrough.md Video Assets
Pattern
assets/videos/... + scripts/storyboards/exports Outputs scripts, storyboards, generated clips, assembled exports, captions, thumbnails, and platform optimization notes depending on route.
Quick Ref / Command
Marketing Kit
💡 Answer technical and architectural questions.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:ask Should we prioritize SEO or paid ads for the VividKit launch? /ckm:ask What headline formula works best for a developer tool landing page? /ckm:ask What channels should we use to reach senior developers effectively? Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
ckm:docs command family
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:docs:init marketing docs for VividKit including brand guide and campaign templates /ckm:docs:llms Generate LLM-friendly documentation for the ClaudeKit marketing skill set /ckm:docs:update after the Q3 campaign retrospective Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
💡 Write some journal entries.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:journal Document the lessons learned from the Product Hunt launch campaign /ckm:journal Log the decision to pivot from paid ads to community-led growth /ckm:journal Write a weekly marketing recap for the beta launch week Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
💡💡💡 Intelligent plan creation with prompt enhancement
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:plan Create a plan for the VividKit beta launch campaign across all channels /ckm:plan Plan a 3-month SEO content strategy for ClaudeKit targeting developer keywords /ckm:plan Build the Q4 marketing plan with budget allocation and OKRs Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Path to markdown file, plan directory, or plans collection
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:preview Show a visual preview of the VividKit launch campaign timeline /ckm:preview Diagram the content distribution flow from blog to social to email /ckm:preview Visualize the marketing funnel from awareness to trial for VividKit Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
ckm:test command family
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:test:ui Run visual regression tests on the VividKit landing page components /ckm:test:copy Run A/B test analysis on the two landing page headline variants /ckm:test:qa QA the email campaign content for accuracy, links, and brand consistency Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
💡 Review recent changes and wrap up the work
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:watzup Summarize this marketing strategy session for handoff to the content team /ckm:watzup Write an EOD summary of today's campaign launch activities /ckm:watzup Generate a weekly marketing recap for the team newsletter Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Create isolated git worktree for parallel development
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:worktree Create a worktree for the Q4 campaign assets to work in isolation /ckm:worktree Create a worktree for the brand refresh without affecting active campaigns /ckm:worktree list Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants to plan, design, or implement an A/B test or experiment. Also use when the user mentions "A/B test," "split test," "experiment," "test this change," "variant copy," "multivariate test," or "hypothesis." For tracking implementation, see analytics-tracking.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:ab-test-setup Plan an A/B test for the hero CTA button color on the landing page /ckm:ab-test-setup Analyze the results of our last A/B test with 5000 users per variant /ckm:ab-test-setup Design a multivariate test for the pricing page headline, subheading, and CTA Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Activate for paid advertising campaigns on Google Ads, Meta Ads, LinkedIn Ads, TikTok Ads. Includes ad copywriting, audience targeting, budget optimization, A/B testing, ROAS tracking, and AI creative asset generation (images & videos) with ai-multimodal and ai-artist skills using Gemini Nano Banana Pro and Veo 3.1.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:ads-management Audit our Google Ads campaigns for wasted spend and optimization opportunities /ckm:ads-management Create a Facebook Ads campaign for the VividKit beta launch targeting developers /ckm:ads-management Optimize bidding strategy for max conversions under $20 CPA for the signup campaign Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Build high-converting SaaS affiliate programs with 20-40% commissions, KOL/KOC partnerships, and fraud prevention. Covers platform selection (PartnerStack, FirstPromoter, Rewardful), commission structures (recurring vs one-time, tiered), influencer outreach strategies, FTC/GDPR compliance, risk management, and case studies (Dropbox 3900%, PayPal 100M users). Use for designing affiliate programs, recruiting partners, optimizing conversion rates, preventing fraud, or scaling referral revenue.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:affiliate-marketing Design an affiliate program for VividKit with tiered commissions for developers and agencies /ckm:affiliate-marketing Create an outreach plan to recruit developer bloggers as affiliates for ClaudeKit /ckm:affiliate-marketing Analyze affiliate performance data and identify top performers and inactive affiliates Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Activate for marketing analytics, KPI tracking, reporting dashboards, attribution analysis, and performance optimization. Use when analyzing campaign data, creating reports, or measuring marketing ROI.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:analytics Design a product analytics dashboard tracking activation, retention, and revenue KPIs /ckm:analytics Analyze the signup-to-activation funnel and identify the biggest drop-off point /ckm:analytics Create an event tracking plan for the new onboarding flow using Segment Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
💡💡 Analytics and performance reports
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:analyze Analyze this CSV of 10,000 user sessions and identify engagement patterns /ckm:analyze Run a cohort analysis on user signups by week for the past 6 months /ckm:analyze Compare VividKit features against Cursor and Copilot across pricing, AI quality, and workflow Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Organize all outputs from slash commands and subagents in assets/ directory by topics, date format, and slugs.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:assets-organizing Organize the assets/ folder with consistent naming and sub-folder structure for the rebrand /ckm:assets-organizing Package brand assets into a structured kit with logos, colors, fonts, and usage guide /ckm:assets-organizing Audit the current marketing assets for outdated branding and missing formats Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Brand voice, visual identity, messaging frameworks, asset management, brand consistency. Activate for branded content, tone of voice, marketing assets, brand compliance, style guides.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:brand Develop brand strategy for VividKit targeting AI-native developers with premium positioning /ckm:brand Define the brand voice and writing style guidelines for ClaudeKit marketing copy /ckm:brand Create visual identity direction: primary/secondary colors, type pairing, and logo usage rules Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Corporate Identity Program design with 50 deliverables, 20 styles, 20 industries. Generate CIP mockups with Gemini Nano Banana (Flash/Pro). Actions: design, create, generate brand identity. Deliverables: business card, letterhead, signage, vehicle, apparel, packaging. Styles: corporate, luxury, minimal, modern.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:cip-design Design professional business cards for VividKit team with QR code and minimalist style /ckm:cip-design Create branded letterhead and email signature templates for VividKit /ckm:cip-design Build a brand presentation deck for pitching VividKit to enterprise clients Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Activate when users ask about Claude Code installation, slash commands (/plan, /fix, /content, /docs, /design, /git), creating/managing Agent Skills, configuring MCP servers, setting up hooks/plugins, IDE integration (VS Code, JetBrains), CI/CD workflows, enterprise deployment (SSO, RBAC, sandboxing), troubleshooting authentication/performance issues, or advanced features (extended thinking, caching, checkpointing).
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:claude-code Set up Claude Code with MCP servers, custom hooks, and project CLAUDE.md for this repo /ckm:claude-code Create a custom ClaudeKit skill for automating API documentation generation /ckm:claude-code Configure pre-tool-use hooks for secret scanning and post-message hooks for auto-journaling Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Competitive analysis, alternative pages, vs comparisons, SEO competitor content, market positioning, and battlecard generation.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:competitor Analyze Cursor, Copilot, and Windsurf as competitors to VividKit across features and pricing /ckm:competitor Analyze 50 recent deal outcomes to identify why we win and lose against Cursor /ckm:competitor Create sales battle cards for competing against Copilot in enterprise deals Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Browser-based asset gallery for managing marketing assets. Visual grid with filter/search, brand context sidebar, and actions (preview, edit, generate). R2-ready manifest for future cloud sync. Use when browsing assets, managing content library, or generating new assets with brand context.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:content-hub Create a 3-month content calendar for ClaudeKit across blog, social, and email channels /ckm:content-hub Repurpose the How ClaudeKit Works guide into 5 Twitter threads and 3 LinkedIn posts /ckm:content-hub Design a content cluster for AI coding tools with pillar page and 8 supporting articles Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Activate for content strategy, editorial calendars, content pillar mapping, blog planning, and content audit. Use when planning content programs, creating editorial workflows, or building topic clusters.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:content-marketing Develop a content marketing strategy for ClaudeKit targeting developer audiences /ckm:content-marketing Write a case study about how a team used ClaudeKit to ship 3x faster /ckm:content-marketing Create a distribution plan for the new ClaudeKit guide launch across owned and earned channels Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Creative direction intelligence. 55 styles, 18 platforms, 12 voiceover types, 17 music genres, 30 campaign categories. Actions: create, design, plan, direct, brief creative campaigns. Projects: ads, videos, social content, commercials, brand films. Styles: minimalist, maximalist, nostalgic, cinematic, UGC, luxury, futuristic, emotional. Topics: visual style, platform specs, voiceover, music, color palette, audience targeting.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:creativity Brainstorm 10 creative campaign concepts for the VividKit beta launch targeting developers /ckm:creativity Generate 20 product name ideas for an AI code review tool targeting senior developers /ckm:creativity Write 15 tagline variants for VividKit ranging from technical to emotional Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Launch and manage the Marketing Dashboard
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:dashboard Build a marketing performance dashboard with acquisition, activation, and retention KPIs /ckm:dashboard Design a product analytics dashboard for feature adoption and user engagement /ckm:dashboard Create an MRR dashboard with growth rate, churn, expansion, and LTV tracking Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Systematic debugging framework ensuring root cause investigation before fixes. Includes four-phase debugging process, backward call stack tracing, multi-layer validation, and verification protocols. Use when encountering bugs, test failures, unexpected behavior, performance issues, or before claiming work complete. Prevents random fixes, masks over symptoms, and false completion claims.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:debugging Investigate why the checkout API returns 422 for valid card numbers in production /ckm:debugging Debug why the dashboard page takes 8 seconds to load after the latest deploy /ckm:debugging Find the polluter causing the auth test suite to fail intermittently in CI Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Token architecture, component specifications, and slide generation. Three-layer tokens (primitive→semantic→component), CSS variables, spacing/typography scales, component specs, strategic slide creation. Use for design tokens, systematic design, brand-compliant presentations.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:design-system Create a design token system for VividKit with semantic colors, spacing, and typography /ckm:design-system Audit the existing UI components for consistency and create a design system documentation /ckm:design-system Design an icon system for VividKit with consistent weight, style, and grid alignment Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Generate speech, clone voices, create sound effects & music with ElevenLabs API. TTS, voice design, audio generation, conversational AI agents.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:elevenlabs Generate narration for the VividKit product walkthrough video using the English_Warm voice /ckm:elevenlabs Clone the brand voice from the provided audio sample for consistent product narration /ckm:elevenlabs Convert this blog post into a 5-minute podcast episode with natural speech patterns Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants to optimize any form that is NOT signup/registration — including lead capture forms, contact forms, demo request forms, application forms, survey forms, or checkout forms. Also use when the user mentions "form optimization," "lead form conversions," "form friction," "form fields," "form completion rate," or "contact form." For signup/registration forms, see signup-flow-cro. For popups containing forms, see popup-cro.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:form-cro Audit the signup form for friction and suggest CRO improvements to increase completion rate /ckm:form-cro Optimize the 3-step checkout form to reduce cart abandonment /ckm:form-cro Design an A/B test for the lead capture form with fewer fields vs. more fields Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants to plan, evaluate, or build a free tool for marketing purposes — lead generation, SEO value, or brand awareness. Also use when the user mentions "engineering as marketing," "free tool," "marketing tool," "calculator," "generator," "interactive tool," "lead gen tool," "build a tool for leads," or "free resource." This skill bridges engineering and marketing — useful for founders and technical marketers.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:free-tool-strategy Develop a free tool strategy for ClaudeKit to attract developers through workflow calculators /ckm:free-tool-strategy Design an SEO-optimized landing page for the ClaudeKit token calculator tool /ckm:free-tool-strategy Map the conversion funnel from free tool usage to paid subscription for VividKit Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
💡💡 Funnel design and optimization
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:funnel Audit the signup-to-activation funnel and identify the top 3 drop-off points /ckm:funnel Design a product-led growth funnel for a B2B developer tool with freemium model /ckm:funnel Write copy for each stage of the trial-to-paid upgrade funnel Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Design gamified marketing campaigns using points, badges, leaderboards, streaks, challenges. Use for loyalty programs, referral campaigns, onboarding flows, engagement boosts, email gamification. Provides mechanics selection, psychology alignment, strategy docs, templates, KPIs.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:gamification-marketing Design a points and badges system for ClaudeKit user engagement /ckm:gamification-marketing Create a gamified referral system with milestones and unlockable rewards for VividKit /ckm:gamification-marketing Design a developer leaderboard for ClaudeKit usage streaks and skill completions Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Open Content Hub + Marketing Dashboard
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:hub Create a marketing resource hub with campaign templates, brand assets, and workflow guides /ckm:hub Build a knowledge base for the ClaudeKit marketing team with onboarding and playbooks /ckm:hub Organize all marketing copy and creative assets into a searchable content library Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
💡💡💡💡 Initialize marketing project
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:init skill analytics-reporting /ckm:init project E-commerce API with Node.js and PostgreSQL /ckm:init workflow weekly-review for automated report generation Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Build ClaudeKit Marketing components - skills, agents, commands, workflows. Use when creating new automation, extending marketing capabilities, or understanding kit structure. Includes templates, examples, and init scripts.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:kit-builder Create a Next.js SaaS starter kit with auth, Stripe billing, and dark mode /ckm:kit-builder Build a kit for creating TypeScript CLI tools with argument parsing and config management /ckm:kit-builder Create a kit for building typed API clients from OpenAPI specs Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants to plan a product launch, feature announcement, or release strategy. Also use when the user mentions 'launch,' 'Product Hunt,' 'feature release,' 'announcement,' 'go-to-market,' 'beta launch,' 'early access,' 'waitlist,' or 'product update.' This skill covers phased launches, channel strategy, and ongoing launch momentum.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:launch-strategy Create a launch plan for VividKit beta targeting developer communities /ckm:launch-strategy Design a waitlist strategy for VividKit with referral incentives and anticipation building /ckm:launch-strategy Plan a community launch for ClaudeKit on Hacker News, Product Hunt, and Dev.to Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Logo design intelligence with 55 styles, 30 color palettes, 25 industries. Generate logos with Gemini Nano Banana model, search styles/colors/industries. Actions: design, create, generate logo. Industries: tech, healthcare, finance, food, fashion, fitness. Styles: minimalist, vintage, luxury, geometric, abstract, mascot, emblem. Features: AI prompt generation, design briefs, color psychology.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:logo-design Create 5 logo concepts for VividKit with minimalist, tech-forward aesthetic /ckm:logo-design Refine the selected logo mark with dark/light variants and icon-only version /ckm:logo-design Create a logo usage guide with clearspace, minimum size, and incorrect use examples Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Local-first marketing command center for solopreneurs. Manage campaigns, content, and assets with Claude Code AI automation.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:marketing-dashboard Design a marketing KPI dashboard covering acquisition, engagement, and revenue /ckm:marketing-dashboard Build a campaign performance tracker for all active paid and organic channels /ckm:marketing-dashboard Set up multi-touch attribution tracking across email, social, and paid for the funnel Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user needs marketing ideas, inspiration, or strategies for their SaaS or software product. Also use when the user asks for 'marketing ideas,' 'growth ideas,' 'how to market,' 'marketing strategies,' 'marketing tactics,' 'ways to promote,' or 'ideas to grow.' This skill provides 140 proven marketing approaches organized by category.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:marketing-ideas Generate 10 creative campaign ideas for the ClaudeKit launch targeting senior developers /ckm:marketing-ideas List 15 growth hacking ideas for a developer tool with a freemium model /ckm:marketing-ideas Design viral mechanics for VividKit referral program to increase developer word-of-mouth Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Plan marketing strategies, campaigns, content calendars, and initiatives using proven frameworks (RACE, SOSTAC, STP). Activates marketing-research for data-driven insights.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:marketing-planning Create a Q3 marketing plan for VividKit with budget allocation and channel mix /ckm:marketing-planning Develop a go-to-market plan for ClaudeKit entering the enterprise market /ckm:marketing-planning Define the optimal channel mix for reaching AI-native developers at low CAC Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants to apply psychological principles, mental models, or behavioral science to marketing. Also use when the user mentions 'psychology,' 'mental models,' 'cognitive bias,' 'persuasion,' 'behavioral science,' 'why people buy,' 'decision-making,' or 'consumer behavior.' This skill provides 70+ mental models organized for marketing application.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:marketing-psychology Apply loss aversion and social proof principles to the pricing page copy /ckm:marketing-psychology Audit the onboarding flow for cognitive bias opportunities and friction points /ckm:marketing-psychology Design nudges for the free-to-paid upgrade flow using commitment and consistency Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Research market trends, competitors, audience insights, and marketing best practices. Use before marketing-planning for data-driven strategy.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:marketing-research Plan and conduct user interviews with 5 ClaudeKit beta users to understand workflow pain points /ckm:marketing-research Design a product-market fit survey for VividKit early access users /ckm:marketing-research Size the TAM/SAM/SOM for AI developer tools targeting individual developers in 2025 Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants to optimize post-signup onboarding, user activation, first-run experience, or time-to-value. Also use when the user mentions "onboarding flow," "activation rate," "user activation," "first-run experience," "empty states," "onboarding checklist," "aha moment," or "new user experience." For signup/registration optimization, see signup-flow-cro. For ongoing email sequences, see email-sequence.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:onboarding-cro Audit the current 5-step onboarding flow and identify where users drop off most /ckm:onboarding-cro Redesign the onboarding to get users to their aha moment within 3 minutes /ckm:onboarding-cro Add contextual tooltips and progressive disclosure to the dashboard for new users Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants help with paid advertising campaigns on Google Ads, Meta (Facebook/Instagram), LinkedIn, Twitter/X, or other ad platforms. Also use when the user mentions 'PPC,' 'paid media,' 'ad copy,' 'ad creative,' 'ROAS,' 'CPA,' 'ad campaign,' 'retargeting,' or 'audience targeting.' This skill covers campaign strategy, ad creation, audience targeting, and optimization.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:paid-ads Set up Google Search Ads for ClaudeKit targeting AI coding tools and competitor keywords /ckm:paid-ads Create a retargeting campaign for VividKit pricing page visitors who did not convert /ckm:paid-ads Analyze last month paid ad performance and recommend budget reallocation Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
>
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:play Build a quick prototype for a command palette feature to test the interaction model /ckm:play Explore WebGL water simulation as a potential hero background /ckm:play Spike a WebSocket connection handler to understand the complexity before planning Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
When the user wants help with pricing decisions, packaging, or monetization strategy. Also use when the user mentions 'pricing,' 'pricing tiers,' 'freemium,' 'free trial,' 'packaging,' 'price increase,' 'value metric,' 'Van Westendorp,' 'willingness to pay,' or 'monetization.' This skill covers pricing research, tier structure, and packaging strategy.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:pricing-strategy Design a pricing model for VividKit with freemium, pro, and team tiers /ckm:pricing-strategy Write compelling pricing page copy highlighting value over cost for VividKit Pro /ckm:pricing-strategy Design an A/B test to validate $29 vs $49 per month for the Pro plan Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Build referral programs for SaaS/digital products. Covers reward structures (two-sided, tiered, multi-step), platform selection (Rewardful, ReferralCandy, Viral Loops, FirstPromoter), technical implementation (tracking, attribution, API patterns), fraud prevention, email templates, and KPI metrics. Use for designing viral growth loops, implementing refer-a-friend features, or optimizing existing referral systems.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:referral-program-building Design a referral program for VividKit with two-sided incentives for referrer and referee /ckm:referral-program-building Create a launch plan for the ClaudeKit referral program targeting existing beta users /ckm:referral-program-building Analyze the referral program metrics and suggest improvements to increase viral coefficient Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Create strategic HTML presentations with Chart.js, design tokens, responsive layouts, copywriting formulas, and contextual slide strategies.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:slides Create an investor pitch deck for VividKit with problem, solution, market, and traction slides /ckm:slides Build a product demo presentation for ClaudeKit showing the plan-cook-ship workflow /ckm:slides Create workshop slides for a 45-minute session on AI coding workflows with exercises Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
S3 storage operations - upload, sync, list, get URLs
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:storage Configure AWS S3 bucket for user file uploads with presigned URLs and CloudFront CDN /ckm:storage Migrate existing S3 bucket to Cloudflare R2 for cost savings on egress /ckm:storage Set up bucket policies, lifecycle rules, and versioning for the media storage bucket Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Convert YouTube videos to blog posts, infographics, social content. Download video/audio, get captions/transcripts, generate AI summaries, analyze comments via VidCap.xyz API.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:youtube Optimize the ClaudeKit workflow demo video title, description, tags, and chapters for SEO /ckm:youtube Create a YouTube channel strategy for VividKit targeting developer educators /ckm:youtube Write a YouTube community post announcing the ClaudeKit How-CK-Works guide launch Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Design YouTube thumbnails with 17 styles, niche-specific guides, and CTR optimization. Generate complete thumbnails with text using Gemini Nano Banana Pro (4K text rendering). Actions: design, create, generate thumbnail. Niches: tech, gaming, education, cooking, fitness, business. Styles: facecam, before-after, listicle, diagram, whiteboard, bold-text, mystery, dark-dramatic. Features: AI generation with text baked in, brand identity, reference face, arrows, Google Font support.
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:youtube-thumbnail-design Create a thumbnail for a ClaudeKit workflow tutorial with bold text and a developer face /ckm:youtube-thumbnail-design Design a consistent thumbnail template for the VividKit guide series /ckm:youtube-thumbnail-design Create two thumbnail variants for A/B testing the launch video CTR Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
AI agent orchestration board (Coming Soon)
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:kanban Set up a Kanban board for the Q3 marketing campaign with columns and WIP limits /ckm:kanban Create a sprint Kanban for the VividKit launch with designer and developer lanes /ckm:kanban Triage the marketing backlog and prioritize the top 10 items for this sprint Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
ckm:skill command family
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:skill:add /ckm:skill:create /ckm:skill:fix-logs /ckm:skill:optimize /ckm:skill:optimize:auto /ckm:skill:plan /ckm:skill:update Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Quick Ref / Command
Marketing Kit
Utilize tools of Model Context Protocol (MCP) servers
Invoke
Context
Route
Execute
Scope first
Routing
Use real project context
Context audit
Prefer explicit routes
Artifact generation
Core lanes from input to output, aligned with the command's real execution path.
Start
Input, scope, route
Work
Agent / skill execution
Verify
Gate, review, validation
Concrete invocations for each flag, subcommand, mode, or route available in the live workflow.
/ckm:use-mcp List all available tools from the connected MCP servers /ckm:use-mcp Execute the file_search tool to find all TypeScript files with auth patterns /ckm:use-mcp Use the graph_query tool to find related files then read each one for context Workflow Output
Pattern
Artifact path or inline result + validation summary + skipped checks The guide models the command as a scoped pipeline: route, execute, validate, then summarize artifacts and limitations.
Keyboard: Space = Play/Pause · ← → = Prev/Next step