Workflow Recipes

Ready-to-use command sequences for common development tasks.

New to ClaudeKit?

These workflows consist of sequences of commands that work together to accomplish common tasks. Perfect for getting started!

Workflow Recipes

Getting Started

3 workflows

Build a New Feature

Beginner

Best for: Adding new functionality to your app

~15-30 min 4 steps

/ck:brainstorm Explore ideas

Use /ck:brainstorm or say "brainstorm ideas for [feature]" to explore possibilities

/ck:plan Create implementation plan

AI creates a detailed step-by-step plan for building your feature

Review → /clear → Implement

Review plan, run /clear to free context (mandatory), then implement

/ck:cook @plan.md Implement the plan

AI writes the code following the plan, runs tests, and reviews the work

/clear is mandatory after /ck:plan before /ck:cook

Quick Implementation

Intermediate

Best for: Small features when you know what you want

~10-20 min 1 steps

/ck:cook "your task" All-in-one skill

AI researches, plans, implements, tests, and reviews the feature automatically

What /ck:cook "your task" does automatically:

Research best approaches and technologies
Create and execute implementation plan
Write and test the code
Review for quality and best practices

/ck:cook Flags

--interactive

Step-by-step with approval (default)

--fast

Skip research, quick implementation

--parallel

Run phases in parallel

--auto

Auto-approve all steps

--no-test

Skip test runs after coding

--tdd

Tests-first per phase, works with any other mode

--interactive is default, uses native Claude Tasks API.

Start New Project

Advanced

Best for: Creating a complete app from scratch

~1-2 hours 1 steps

/ck:bootstrap "describe your app" Complete project setup

AI builds your entire project: research, architecture, design, implementation, and documentation

What /ck:bootstrap "describe your app" does automatically:

Research and tech stack selection
Project structure and architecture
UI/UX design and wireframes
Complete implementation with tests
Comprehensive documentation

Warning: This uses significant AI tokens

Design & Frontend

4 workflows

Excalidraw Diagram Generation

Intermediate

Best for: Creating hand-drawn style diagrams that argue visually — shapes mirror meaning

~5-15 min 1 steps

/excalidraw Generate diagram

Generate hand-drawn Excalidraw diagrams from text prompts — architecture, flowcharts, system designs

What /excalidraw does automatically:

Hand-drawn style with semantic color palettes
Auto-diagram: zero-config codebase visualization
File-based workflow with Playwright rendering
MCP canvas workflow for live editing

Supports auto-diagram mode: analyze any codebase and generate architecture diagram automatically

Publication Diagrams (tech-graph)

Intermediate

Best for: Generating publication-quality SVG diagrams for docs, slides, blog posts

~5-15 min 1 steps

/ck:tech-graph "<topic or system>" Generate SVG diagram

Render publication-grade SVG with 7 design styles (modern, minimal, neon, retro, etc.) and 10 templates (architecture, sequence, ER, flowchart, state-machine, timeline, comparison-matrix, use-case, agent-architecture, data-flow)

What /ck:tech-graph "<topic or system>" does automatically:

7 design styles: flat-icon, dark-terminal, blueprint, notion-clean, glassmorphism, claude-official, openai
10 diagram templates incl. agent-architecture and data-flow
SVG layout best-practices baked in (spacing, arrow routing, z-index)
Output ready for docs/slides/blog without manual cleanup

Pair with /ck:preview --diagram for visual self-review (auto-detects collisions, label overlaps, arrow routing issues)

Frontend Design Aesthetics

Advanced

Best for: Creating distinctive, production-grade frontend interfaces that avoid generic AI slop

~30-60 min 4 steps

/ck:ui-ux-pro-max Design Intelligence

Activate ui-ux-pro-max logic to formulate styling references

Mandatory Gate

Commit to a BOLD direction. Define Purpose, Tone, Constraints, and Differentiation.

Design Rules

Ensure font size >= 16px for inputs, mobile-first layouts, and Anti-slop Google Fonts.

/ck:frontend-design Implement Interface

Execute the spec following the design dials: Motion, Variance, Density.

What /ck:frontend-design does automatically:

Design Dials: Variance, Density, Motion Intensity
Mandatory strict Design Thinking gates
Motion rules: CSS for HTML, Motion for React
Production-ready aesthetic choices

Anti-slop typography demands trending Google Fonts with Vietnamese coverage (e.g. Satoshi, Inter)

AI Design Generation (Stitch)

Intermediate

Best for: Generating high-fidelity UI designs from text prompts via Google Stitch

~5-15 min 3 steps

/ck:stitch generate "prompt" Generate design

Create UI designs from text prompts using Google Stitch AI

/ck:stitch export --format all Export assets

Export as Tailwind/HTML + DESIGN.md spec for implementation

/ck:frontend-design Implement components

Build React components from the exported design spec

What /ck:stitch generate "prompt" does automatically:

Text-to-UI design via Google Stitch API
Export to Tailwind/HTML and DESIGN.md
Design-to-code pipeline with existing skills
Supports mobile, desktop, and tablet layouts
Quota: 200 credits/day (Flash), 50/day (Pro)

Set up Stitch MCP server in .claude/.mcp.json for direct tool integration

Debugging & Fixes

4 workflows

Fix a Bug

Beginner

Best for: Structured diagnosis and repair of bugs

~10-20 min 6 steps

/ck:fix 6-step pipeline

Runs the full pipeline: Scout → Diagnose → Assess → Fix → Verify → Prevent

① Scout

Gather evidence — logs, stack traces, affected files

② Diagnose → ③ Assess

Root-cause analysis based on evidence, then severity/impact assessment

④ Fix

Apply targeted fix based on diagnosed root cause

⑤ Verify

Run tests to confirm fix works and no regressions

⑥ Prevent

Add guards, tests, or documentation to prevent recurrence

/ck:fix Flags

--auto

Auto-apply fix without confirmation

--review

Review fix before applying

--quick

Fast fix without deep analysis

--parallel

Fix multiple issues in parallel

/ck:fix v2.0: evidence-based RCA, no guessing. Flags: --auto, --review, --quick, --parallel

Security Audit

Intermediate

Best for: Finding security vulnerabilities and secrets

~15-25 min 3 steps

/ck:security-scan Scan for vulnerabilities

Scan codebase for OWASP issues, hardcoded secrets, and dependency vulnerabilities

/ck:code-review --security Security-focused review

Deep code review focusing on authentication, authorization, and data handling

/ck:fix --security Apply security fixes

AI applies recommended security fixes with detailed explanations

What /ck:security-scan does automatically:

Hardcoded secrets detection
Dependency vulnerability scan
OWASP Top 10 coverage
Security fix recommendations

Detects SQL injection, XSS, CSRF, and other OWASP Top 10 issues

Generate Test Scenarios

Beginner

Best for: Comprehensive edge case discovery before implementation or testing

~5-10 min 1 steps

/ck:scenario 12-dimension analysis

Decompose features across 12 dimensions to generate comprehensive test scenarios

What /ck:scenario does automatically:

12-dimension feature decomposition
Edge case and boundary condition discovery
Test scenario generation with priorities
Integration with /ck:test for execution

Use before writing tests to ensure complete coverage of edge cases

STRIDE Security Audit

Intermediate

Best for: Comprehensive STRIDE + OWASP security analysis with optional auto-fix

~10-20 min 1 steps

/ck:security STRIDE audit

STRIDE threat modeling + OWASP scan with severity categorization and optional auto-fix

What /ck:security does automatically:

STRIDE threat modeling framework
OWASP vulnerability pattern matching
Severity categorization and prioritization
Optional iterative auto-fix using /ck:loop pattern

Combine with /ck:security-scan for comprehensive vulnerability + threat coverage

Planning & Review

7 workflows

Code Review with Edge Cases

Intermediate

Best for: Thorough code review with edge case scouting

~20-30 min 4 steps

/ck:cook @plan.md Implement the plan

AI writes the code following the plan with auto test & review cycles

/ck:scout Scout edge cases

AI scouts affected files, data flows, error paths, and boundary conditions

Code-reviewer review

Code-reviewer subagent reviews findings from scout and evaluates code quality

/ck:git cm Merge & commit

Commit the reviewed code with conventional commit message

What /ck:scout does automatically:

Edge case detection via /ck:scout
Boundary condition analysis
Data flow & error path scouting
Automated code-reviewer integration

/ck:scout integrates with code-reviewer for edge case detection before review

Plan + Validate + Implement

Intermediate

Best for: Validated plans with auto-propagated decisions

~20-40 min 4 steps

/ck:plan Create plan

AI creates a detailed implementation plan with phases

/ck:plan validate Validate plan decisions

Interview-style validation gate. Decisions auto-propagate to phase files

/clear (mandatory)

Free context before implementation. Mandatory step

/ck:cook @plan.md Implement validated plan

AI implements with validated decisions already propagated to each phase

What /ck:plan validate does automatically:

Interview-style plan validation
Auto-propagation to phase files
Validated decisions guide implementation
Reduced rework from unclear plan decisions

/ck:plan Flags

--hard

Complex multi-phase plan with red-team review

--deep

Deep analysis: file inventory, test scenarios, dependency map per phase

--parallel

Plan designed for parallel agent execution

--two

Two-phase plan (plan → implement)

--tdd

Tests-first per phase, works with any other flag

validate

Interview-style validation gate

red-team

Spawn adversarial reviewers

/ck:plan validate decisions auto-propagate to phase files

Adversarial Plan Review

Advanced

Best for: Finding flaws in plans before implementation

~10-20 min 2 steps

/ck:plan --hard "feature" Create plan

Create a detailed plan. Hard/parallel/two modes auto-run red-team after creation

/ck:plan red-team plans/ Adversarial review

Spawn hostile reviewers: Security, Failure Mode, Assumption Destroyer, Scope Critic

What /ck:plan --hard "feature" does automatically:

Security Adversary (auth bypass, injection, OWASP)
Failure Mode Analyst (race conditions, data loss)
Assumption Destroyer (unstated deps, false claims)
Scope & Complexity Critic (over-engineering, YAGNI)

Auto-scales reviewers based on plan complexity (2-4 adversarial lenses)

Extract & Port Features (Xia)

Advanced

Best for: Analyzing and porting features from external GitHub repos into your project

~10-30 min 3 steps

/ck:xia <repo> --compare Analyze source

Compare source repo architecture, patterns, and feature implementation side-by-side

/ck:xia <repo> [feature] --improve Port & refactor

Copy feature from source and refactor to fit local codebase patterns

/ck:test Validate port

Run tests to verify ported feature works correctly in local context

What /ck:xia <repo> --compare does automatically:

Analyze any GitHub repo or local path
Challenge framework stress-tests decisions
AI auto-generates trade-off matrix and risk scores before coding

/ck:xia Flags

Mode

--compare

Side-by-side architectural and pattern analysis only

--copy

Code transplant with absolute minimal modifications

--improve

Bring codebase over but refactor to clean up anti-patterns

--port

Extract core logic and rewrite idiomatically for local stack (Default)

Speed

--fast

Skip research and challenge phases, auto-approve immediately

--auto

Keep the full workflow, but auto-approve gates

Default

Full workflow with approval gates

Use --compare first to assess architecture compatibility before porting

Knowledge Graph Navigation

Intermediate

Best for: Understanding unfamiliar codebases through structural analysis before planning

~5-15 min 2 steps

/ck:graphify Build graph

Analyze codebase with tree-sitter AST, generate interactive visualization + report

/ck:plan Plan with context

Use GRAPH_REPORT.md to understand architecture before creating implementation plan

What /ck:graphify does automatically:

20+ language support via tree-sitter AST
Interactive HTML visualization with search
God nodes and surprising connections report
71.5x fewer tokens vs raw file context

Use --watch for incremental updates as you code. MCP mode exposes graph to Claude for direct queries.

Predict Impact Before Coding

Intermediate

Best for: Catching architectural, security, and performance issues before implementation

~5-10 min 1 steps

/ck:predict 5-persona debate

5 expert personas debate proposed changes — architect, security, performance, UX, ops

What /ck:predict does automatically:

5 expert personas with distinct viewpoints
Architecture, security, performance analysis
UX and ops impact assessment
Consensus report with risk ratings

Run before major features or risky refactors to catch issues early

Review & Merge a PR

Intermediate

Best for: Reviewing a GitHub pull request for standards, security, and breaking changes before merge

~10-20 min 3 steps

/ck:review-pr <PR> Review the PR

Checks duplicate prior work, project standards, strategic necessity, correctness, security, breaking changes, and AI-slop patterns

/ck:review-pr <PR> --fix --reply Auto-fix & reply

Apply the findings to the working tree and post the formal review back to GitHub

/ck:git merge Merge when green

Merge once approved and CI passes

review-pr supports --fix (apply) and --reply (post to GitHub)

Research & Docs

3 workflows

Visual Documentation

Beginner

Best for: Creating visual explanations, diagrams, and slide decks as Markdown or self-contained HTML

~2-10 min 3 steps

/ck:preview --explain "topic" Markdown explanation

Create ASCII + Mermaid diagrams with prose explanation (opens in novel-reader UI)

/ck:preview --html --explain "topic" HTML explanation

Self-contained HTML with theme toggle, Mermaid v11, and Chart.js — opens directly in browser

/ck:preview --html --slides "topic" HTML slide deck

Magazine-quality presentation slides as self-contained HTML

What /ck:preview does automatically:

Markdown modes: --explain, --slides, --diagram, --ascii
HTML modes: --html --explain, --html --slides, --html --diagram
HTML-only: --diff, --plan-review, --recap
Theme toggle (light/dark) in every HTML page
Mermaid v11 diagrams + Chart.js data visualizations

Add --html to any mode for publication-quality HTML output. Also: --diagram, --diff, --plan-review, --recap

Research & Documentation

Beginner

Best for: Research topics and create technical documentation

~10-20 min 3 steps

/ck:research "topic" Deep research

AI researches the topic thoroughly using web search and documentation

/ck:docs-seeker "library" Search library docs

Search official documentation via llms.txt for up-to-date API info

/ck:docs Generate project docs

Create or update project documentation based on codebase analysis

What /ck:research does automatically:

Web search and synthesis
Library documentation lookup
Project documentation generation
Technical writing assistance

/ck:docs-seeker uses context7 for latest library documentation

LLMs.txt Generation

Beginner

Best for: Making your project AI-friendly for LLM consumption

~5-10 min 1 steps

/ck:llms [path] Generate index

Create llms.txt following llmstxt.org spec — makes your docs AI-readable

What /ck:llms [path] does automatically:

Follows llmstxt.org specification
Generates from docs, README, or codebase
Includes reference files and structure overview
Works with any project type

/ck:llms generates standardized llms.txt so AI tools can quickly understand your codebase

Shipping

4 workflows

DevOps & Deployment

Advanced

Best for: Setting up CI/CD and deployment pipelines

~20-40 min 3 steps

/ck:devops "setup CI/CD" Configure DevOps

Set up CI/CD pipelines for GitHub Actions, GitLab CI, or other platforms

/ck:deploy Deploy to platform

Deploy to Cloudflare, Vercel, GCP, or Kubernetes with auto-detection

/ck:test --e2e Run E2E tests

Verify deployment with end-to-end tests

What /ck:devops does automatically:

CI/CD pipeline generation
Multi-platform deployment
Environment configuration
Rollback and monitoring setup

Supports Docker, Kubernetes, serverless, and container deployments

Ship a Feature

Intermediate

Best for: Shipping feature branches with automated test, review, and PR creation

~5-10 min 1 steps

/ck:ship [--official|--beta] [--skip-tests] [--skip-review] Ship pipeline

Merge main, run tests, pre-landing review, bump version, update changelog, push, create PR

What /ck:ship [--official|--beta] [--skip-tests] [--skip-review] does automatically:

Supports official (→main) and beta (→dev) ship modes
Merges origin/main (or dev for beta) before testing
Auto-detects npm/pytest/cargo/go test
Two-pass code review + adversarial review (stage 3)
Bumps version and updates CHANGELOG.md
Creates PR with summary, test results, and linked issues

/ck:ship auto-detects test runner, version file format, and changelog style

Deploy Your App

Intermediate

Best for: Deploying to Vercel, Netlify, Railway, Fly.io, AWS, GCP and more

~5-15 min 1 steps

/ck:deploy [platform] Auto-deploy

AI detects your project type and deploys to 15+ platforms with zero manual config

What /ck:deploy [platform] does automatically:

Auto-detects project type (Next.js, Astro, Express, etc.)
Supports 15+ platforms out of the box
Handles env vars and build configuration
Vercel, Netlify, Railway, Fly.io, AWS, GCP, Azure

/ck:deploy auto-detects your stack and handles environment variables, build steps, and platform config

Autonomous Feature Delivery

Advanced

Best for: Hands-off delivery from a GitHub issue or feature request to a shipped PR

~30-60 min 2 steps

/ck:vibe Autonomous pipeline

One command takes a GitHub issue or feature request through plan → implement → review → ship (worktree isolation, reusable/TDD plan gates, cook or fix routing, review-pr, merge/CI watch)

Plan gate → PR

Approve the generated plan at the gate; it then implements, self-reviews, and opens a PR

Use /ck:vibe for end-to-end automation; for manual control use /ck:plan → /ck:cook instead

Backend & Infra

2 workflows

Database Operations

Intermediate

Best for: Database schema design and migrations

~15-30 min 3 steps

/ck:databases "schema design" Design schema

Design database schema with relationships, indexes, and constraints

/ck:plan "migration" Plan migration

Create a safe migration plan with rollback strategy

/ck:cook @plan.md Execute migration

Implement migration with proper error handling and validation

What /ck:databases does automatically:

Schema design with relationships
Index optimization
Migration script generation
Query performance analysis

Supports MongoDB, PostgreSQL, MySQL, and SQLite

Agentize Your Codebase

Intermediate

Best for: Converting existing code into AI agent-friendly CLI tools and MCP servers

~15-30 min 3 steps

/ck:agentize --both Generate CLI + MCP

Wrap codebase as both CLI tool and MCP server with shared core/ module

Optimize for AI

Concise outputs, actionable errors, consolidated workflows — designed for LLM consumption

/ck:deploy Deploy to cloud

Deploy to Cloudflare Workers, Docker, or any supported platform

What /ck:agentize --both does automatically:

Shared core/ module for CLI + MCP
Agent-centric output formatting
Actionable error messages for LLMs
Deploy to Cloudflare Workers or Docker

Use --mcp for MCP-only or --cli for CLI-only output. Default --both generates shared core/

Media & Creative

3 workflows

Create Video Content

Intermediate

Best for: Programmatic video creation with React

~20-40 min 2 steps

/ck:remotion Video creation

Create videos programmatically with React and Remotion

render Render output

Export to MP4, GIF, or image sequences

What /ck:remotion does automatically:

Animations and transitions
Text animations and captions
3D graphics integration
Audio synchronization

Creates React-based video compositions

Showcase & Social Media Content

Beginner

Best for: Creating polished HTML showcase pages for demos, articles, and social media posts

~5-10 min 1 steps

/ck:show-off Generate showcase

Create multi-section HTML page with parallax, theme toggle, bilingual content (VI/EN), and auto-captured screenshots

What /ck:show-off does automatically:

Scrollable multi-section layout with parallax effects
Auto theme toggle (system/light/dark)
Parallel screenshot capture in multiple aspect ratios

Outputs screenshots in 16:9, 9:16, and 1:1 aspect ratios — ready for social media platforms

HTML-to-Video Rendering

Intermediate

Best for: Rendering local MP4 videos from HTML/CSS/JS templates (promos, explainers, social clips)

~20-40 min 2 steps

/ck:html-video Scaffold from template

Check out a template (promo, explainer, data video, social clip) and customize it in the studio

Render & verify MP4

Render locally through Chromium + ffmpeg, then verify the output MP4

Renders locally (Chromium + ffmpeg) — no external service needed

Session & Management

1 workflows

Sprint Retrospective

Beginner

Best for: Data-driven sprint reviews with git metrics, health indicators, and actionable recommendations

~2-5 min 1 steps

/ck:retro [timeframe] [--compare] [--team] [--format html|md] Analyze sprint

Gather git metrics (commits, LOC, hotspots, churn), compute health indicators, generate retrospective report

What /ck:retro [timeframe] [--compare] [--team] [--format html|md] does automatically:

Git metrics: commits/day, LOC added/removed, file hotspots
Health indicators: churn rate, test ratio, active day ratio
Period comparison with --compare flag
Per-author breakdown with --team flag
HTML or Markdown output format

/ck:retro 2w --compare --team generates a two-week retro with period comparison and per-author breakdown

Advanced

3 workflows

Agent Teams (Parallel)

Advanced

Best for: Large tasks with multiple parallel agents

~30-60 min 2 steps

/ck:plan --hard "feature" Create plan with phases

Create a detailed plan with parallelizable phases for team execution

/ck:team cook @plan Parallel team execution

Spawn parallel dev agents, each handling a phase. Auto test → review → merge

What /ck:plan --hard "feature" does automatically:

Parallel dev agents (--devs N)
Auto test → review → merge pipeline
Event-driven hooks + agent memory
Also: /ck:team research, /ck:team review, /ck:team debug

/ck:team Flags

--devs N

Number of parallel dev agents (default: 2)

--tester

Include dedicated tester agent

--reviewer

Include code reviewer agent

--worktree

Run each agent in isolated git worktree

Requires CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in settings.json

Isolated Feature Branching

Intermediate

Best for: Parallel development in monorepos using git worktrees

~2-5 min 3 steps

/ck:worktree info Step 1: Get Repo Info

Parse repo type, base branch, and existing projects

Step 2: Detect Branch Naming Mode

Detect conventional prefix or use --no-prefix for exact Jira keys

Step 3: Convert to Slug

Format branch name to kebab-case (skipped if --no-prefix is active)

What /ck:worktree does automatically:

Isolated git worktrees per feature
Preserve exact issue keys (--no-prefix)
Auto-detect branch prefix conventions
Monorepo project scoping support

Use --no-prefix to preserve exact branch names for Jira keys (like ND-1377-cleanup-docs).

Browser Automation (Real Chrome)

Advanced

Best for: Automating or testing logged-in web UIs using your real Chrome profile and cookies

~10-20 min 2 steps

/ck:chrome-profile Target real profile

Discover and target your real Google Chrome profile through Chrome DevTools MCP (real session cookies)

Automate / screenshot

Preview or test authenticated UI, capture screenshots, or scrape with your logged-in session

Use chrome-profile when automation needs your real cookies/account; use web-testing for clean-room E2E

Pro Tips

Save tokens with /clear

Use /clear to clear conversation history before starting implementation

Reference files with @

Use @plan.md to reference specific files in commands

Use /ck:cook for implementation

After planning with /ck:plan, run /clear then /ck:cook to implement your plan

Scout before coding

Use /ck:scout to quickly find relevant files in your codebase

Debug before fixing

Use /ck:debug first to find root cause, then /ck:fix when ready

Always start with /ck:plan

Create a structured plan first, then use /ck:cook to execute it

Agent behavioral checklists

Skills include behavioral checklists that guide agent decision-making — check skill docs for details

Related Guides

Commands Cheat Sheet

Full command reference with complexity ratings

Command Finder

Interactive decision tree for command selection

Need more workflows? See full docs from official ClaudeKit site.

Content & Copy

2 workflows

Write & Publish Blog Post

Beginner

Best for: Creating SEO-optimized blog content from scratch

~20-30 min 4 steps

/ckm:write:good [topic] Research & draft

AI researches topic, analyzes competitors, and drafts SEO-optimized content

/ckm:seo:audit SEO optimization

Audit content for keyword density, meta tags, and search optimization

/ckm:write:enhance Enhance & polish

Improve readability, add CTAs, and optimize for engagement

/ckm:write:publish Publish content

Format for CMS, add images, and prepare for publication

What /ckm:write:good [topic] does automatically:

Competitor content analysis
SEO keyword integration
Readability optimization
CMS-ready formatting

Use /ckm:write:good for quality content; /ckm:write:fast for quick drafts

Create Email Sequence

Intermediate

Best for: Building automated email nurture campaigns

~30-45 min 4 steps

/ckm:persona Define audience

Create buyer persona to target messaging effectively

/ckm:email:flow [welcome] Design email flow

Create automated sequence with timing and triggers

/ck:copywriting Write copy

Craft compelling subject lines and email body copy

/ckm:email:sequence Generate sequence

Output complete email sequence with A/B variants

What /ckm:persona does automatically:

Buyer persona targeting
Automated trigger setup
A/B test variants
ESP-ready export

Include A/B test variants for subject lines to optimize open rates

Campaign & Analytics

2 workflows

Launch Marketing Campaign

Advanced

Best for: Planning and executing multi-channel campaigns

~45-60 min 5 steps

/ckm:plan Strategic planning

Define campaign goals, KPIs, timeline, and budget allocation

/ckm:campaign:create Create campaign

Set up campaign structure with channels and messaging

Content marketing skill

The content-marketing skill plans content pillars & calendar — describe your goal to activate it

/ckm:social:schedule Schedule distribution

Plan and schedule content across social platforms

/ckm:analyze Set up tracking

Configure analytics and conversion tracking

What /ckm:plan does automatically:

Multi-channel coordination
Budget allocation planning
Content calendar generation
Performance tracking setup

Use /ckm:campaign status to monitor performance during campaign

Set Up A/B Testing

Intermediate

Best for: Testing variations to optimize conversion rates

~20-30 min 4 steps

/ckm:funnel analyze Identify bottlenecks

Analyze current funnel to find optimization opportunities

A/B testing skill

The ab-test-setup skill designs variants & tracking — say "set up an A/B test for ..."

/ckm:plan:cro Implementation plan

Create detailed plan for test implementation

/ckm:analyze:report Analyze results

Statistical analysis and recommendations

What /ckm:funnel analyze does automatically:

Hypothesis formulation
Variant design
Statistical significance calc
Winner implementation

Run tests for minimum 2 weeks to get statistically significant results

SEO & Growth

2 workflows

Perform SEO Audit

Beginner

Best for: Comprehensive site health and SEO analysis

~15-25 min 3 steps

/ckm:seo:audit [url] Technical audit

Analyze site structure, speed, mobile-friendliness, and crawlability

/ckm:seo:keywords [niche] Keyword research

Discover high-value keywords and content gaps

/ckm:competitor seo [url] Competitor analysis

Analyze competitor rankings and backlink profiles

What /ckm:seo:audit [url] does automatically:

Technical SEO checklist
Keyword opportunity map
Competitor gap analysis
Priority action items

Run audits monthly to track SEO progress and catch issues early

Optimize Landing Page

Intermediate

Best for: Improving conversion rates on landing pages

~25-35 min 4 steps

/ckm:funnel analyze [url] Analyze performance

Review current metrics, bounce rate, and user flow

Form CRO skill

The form-cro skill optimizes forms for conversion — describe the form to improve

/ck:copywriting Copy optimization

Improve headlines, value props, and persuasion elements

/ckm:plan:cro Create CRO plan

Document changes and set up tracking for improvements

What /ckm:funnel analyze [url] does automatically:

Heatmap analysis
Form field optimization
Copy A/B variants
Conversion tracking

Focus on one optimization at a time to accurately measure impact

Design & Creative

3 workflows

Create Marketing Assets

Intermediate

Best for: Generating cohesive visual assets for campaigns

~30-45 min 4 steps

/ckm:brand review Review brand guidelines

Load brand colors, fonts, and style guidelines

Design system skill

The design-system skill builds brand guidelines & tokens — describe your brand

Design skill (banner)

The design skill generates logos/banners/social graphics — say "design a banner for ..."

Assets organizing skill

The assets-organizing skill files & names your generated assets — run it after creating assets

What /ckm:brand review does automatically:

Brand-consistent design
Multi-size exports
Platform-specific formats
Asset library organization

Use /ckm:brand create to set up brand guidelines first if not exists

Design Social Graphics

Beginner

Best for: Creating engaging social media visuals

~15-25 min 3 steps

Design skill (social)

The design skill creates social graphics — say "design a social graphic for ..."

/ck:copywriting Write captions

Generate engaging captions with hashtags

/ckm:social:schedule Schedule posts

Plan posting schedule for optimal engagement

What does automatically:

Platform-specific sizing
Brand consistency
Caption generation
Hashtag suggestions

Each platform has optimal image sizes — the design skill auto-formats for each target

Excalidraw Diagram Generation

Beginner

Best for: Visualizing marketing funnels, campaign flows, and content strategies in hand-drawn style

~5-15 min 1 steps

/excalidraw Generate diagram

Generate hand-drawn Excalidraw diagrams — marketing funnels, campaign flows, content calendars, competitor maps

What /excalidraw does automatically:

Hand-drawn style with semantic color palettes
Marketing funnels, campaign flows, content maps
Auto-diagram: zero-config codebase visualization
File-based workflow with Playwright rendering

Auto-diagram mode can analyze your project structure and generate architecture/flow diagrams automatically

Strategy & Research

2 workflows

Competitor Analysis

Intermediate

Best for: Understanding competitive landscape and opportunities

~25-35 min 4 steps

/ckm:competitor list Identify competitors

Discover direct and indirect competitors in your space

/ckm:competitor analyze [url] Deep analysis

Analyze positioning, messaging, and unique value props

/ckm:competitor content Content audit

Analyze content strategy, topics, and engagement

Marketing research skill

The marketing-research skill gathers market/audience insights — ask it to research your niche

What /ckm:competitor list does automatically:

Competitor mapping
Positioning analysis
Content gap identification
Opportunity matrix

Track 3-5 key competitors regularly for ongoing intelligence

Define Marketing Plan

Advanced

Best for: Creating comprehensive marketing strategy

~40-60 min 5 steps

/ckm:persona Define personas

Create detailed buyer personas and segments

Marketing research skill

The marketing-research skill gathers market/audience insights — ask it to research your niche

/ckm:funnel design Design funnel

Map customer journey and conversion points

/ckm:plan Strategic plan

Create comprehensive marketing strategy document

/ckm:dashboard Set up tracking

Configure KPI dashboard and reporting

What /ckm:persona does automatically:

Persona development
Channel strategy
Budget allocation
KPI framework

Review and update marketing plan quarterly for best results

Playbook & Orchestration

1 workflows

Run Marketing Playbook

Intermediate

Best for: Orchestrating end-to-end marketing campaigns with templates, goals, and smart suggestions

~30-60 min 4 steps

/ckm:play:create --template saas-launch Create playbook

Choose from templates: saas-launch, product-hunt-launch, content-engine, campaign-sprint

/ckm:play:goals set Set goals

Define KPIs and targets — integrates with GA4, GSC, Stripe metrics

/ckm:play:next Smart next step

AI suggests highest-impact action based on goal gaps and step readiness

/ckm:play:status Track progress

Dashboard view of all steps, goals, and blockers

What /ckm:play:create --template saas-launch does automatically:

Dependency-graph routing between steps
Quality gates for human approval checkpoints
Goal tracking with GA4/GSC/Stripe integration
Smart suggestions based on goal gaps
4 bundled templates: SaaS launch, Product Hunt, content engine, campaign sprint

Use /ckm:play learn to capture insights after completing each step

Video & Media

3 workflows

Design YouTube Thumbnails

Beginner

Best for: Creating CTR-optimized YouTube thumbnails with AI generation

~10-20 min 3 steps

YouTube thumbnail skill

The youtube-thumbnail-design skill creates click-worthy thumbnails — describe the video

/ck:ai-multimodal Review & iterate

Analyze generated thumbnails and refine with feedback

Assets organizing skill

The assets-organizing skill files & names your generated assets — run it after creating assets

What does automatically:

17 art direction styles with CTR impact ratings
Niche-specific guides: tech, gaming, education, cooking, fitness, business
Batch variant generation for A/B testing
Reference face support for consistent branding
Google Font support and arrow overlays

17 art direction styles available: facecam, mystery, bold-text, before-after, and more

Script & Storyboard Video

Intermediate

Best for: Pre-production planning for video content

~25-40 min 3 steps

/ckm:video:script [topic] Write script

Generate video script with hooks, body, and CTA

/ckm:video:storyboard Create storyboard

Visual shot-by-shot breakdown with timing

ElevenLabs skill

The elevenlabs skill generates voiceover audio — provide the script to narrate

What /ckm:video:script [topic] does automatically:

Hook optimization
Scene breakdown
Timing guidance
AI voiceover option

Keep videos under 2 minutes for social media; under 10 for YouTube

Create Video Content

Advanced

Best for: Full video production workflow

~45-60 min 4 steps

/ckm:video:script Script & plan

Create script and production plan

/ckm:video:create Generate video

Create video with AI assistance or edit guidance

/ckm:youtube:social Create clips

Generate social media clips from long-form content

/ckm:seo:keywords [video] Optimize metadata

Create SEO titles, descriptions, and tags

What /ckm:video:script does automatically:

Full production workflow
Social clip generation
SEO optimization
Multi-platform export

Use /ckm:youtube blog to repurpose video into blog content

Pro Tips

Save tokens with /clear

Use /clear to clear conversation history before starting implementation

Reference files with @

Use @plan.md to reference specific files in commands

Use /ck:cook for implementation

After planning with /ck:plan, run /clear then /ck:cook to implement your plan

Scout before coding

Use /ck:scout to quickly find relevant files in your codebase

Debug before fixing

Use /ck:debug first to find root cause, then /ck:fix when ready

Always start with /ck:plan

Create a structured plan first, then use /ck:cook to execute it

Agent behavioral checklists

Skills include behavioral checklists that guide agent decision-making — check skill docs for details

Related Guides

Commands Cheat Sheet

Full command reference with complexity ratings

Command Finder

Interactive decision tree for command selection

Need more workflows? See full docs from official ClaudeKit site.

Related guide

Finding Your Unknowns

Workflows are proven recipes for known situations. Finding Your Unknowns is what you reach for when no recipe fits yet — pinpoint which kind of unknown you are facing, then find or build the workflow.

Open Finding Your Unknowns