VividKit Crystal clear AI coding
VI
Choose Your Setup Get Started with AgentKit Continue with ClaudeKit Migrate from ClaudeKit to AgentKit Clean cutover from ClaudeKit What Is AgentKit? How AgentKit Works AgentKit Kits, Skills, Agents & Hooks AgentKit Runtime Support AgentKit Desktop App AgentKit Configuration AgentKit CLI Quick Reference AgentKit Skills Cheatsheet AgentKit Workflows AgentKit Statusline Update AgentKit CLI & Kits AgentKit Helper Clean reinstall of AgentKit AgentKit Troubleshooting What is ClaudeKit? ClaudeKit CLI Guide Command Finder Commands Cheat Sheet Workflow Recipes CLI Quick Reference Claude Mechanics Permission Modes ClaudeKit Hooks Coexistence ClaudeKit x Codex CK → Other coding tools How ClaudeKit Works Inside ClaudeKit Finding Your Unknowns Session Recovery Fix from Logs UI/UX Guide Accounts Switcher IDE Config Remote Control Codex App System Diagramming UI Review Gate Promotions Support VividKit
AgentKit · Reference workflows

Reference workflows for AgentKit

Unlocking common workflows gradually. More recipes will follow — use them as a starting point and adapt as needed.

How to type commands: In Claude Code or Cursor type /ak:… · In Codex type $ak:…

How to use a reference workflow

1

Pick the workflow closest to your job

Feature, bug, review, ship…

2

Read the suggested skill sequence

It is a reference — shorten or extend as needed

3

Run /ak: commands in a sensible order

Claude Code / Cursor: /ak:… · Codex: $ak:…

A simple way to work

Good results usually follow five beats. Skip steps only when the task is small and low risk.

  1. Understand
  2. Decide
  3. Do
  4. Check
  5. Ship

Advice

Two ways to get advice

Pick one path that fits — you do not need both every time.

Pressure-test before you commit

/ak:advise

Use /ak:advise for an honest second opinion before you lock a direction. It runs on the main session model (not kongming), interviews you one question at a time, you confirm the reframing, then you get actionable advice and a checklist — no code.

Kongming checkpoint while you work

--advice kongming on plan, cook, fix…

Add --advice to /ak:brainstorm, /ak:plan, /ak:cook, /ak:fix, or /ak:vibe so kongming supervises mid-run. It cannot approve or replace your plan review. Different from /ak:advise (and from --agent).

Skip --advice for tiny one-file edits. --hard --advice is expensive — keep for high-risk work.

Filter by kind of work

Choose by level

Start with the easy level if you are new to AgentKit.

Recommended

Common workflows

Frequently useful skill sequences — pick the closest job, then adapt steps to your context.

Getting started

Some practice

Build a new feature

Use when: Feature with unclear shape or multi-file impact

~30–90 min · 7 steps

  1. 1
    /ak:brainstorm

    Explore options

    Compare approaches before locking a plan

  2. 2
    /ak:plan

    Write the plan

    Produce a phased plan you can hand to cook

  3. 3
    Review plan Your turn

    Read and accept (or revise) before coding

  4. 4
    /ak:cook /path/to/plan.md

    Implement

    Execute the plan; pass the plan path

  5. 5
    /ak:test

    Verify

    Run tests for the change

  6. 6
    /ak:code-review

    Review code

    Catch regressions and quality issues

  7. 7
    /ak:ship

    Open PR / ship

    Merge-main hygiene, push, PR

Optional: add --advice

/ak:plan --advice "…"/ak:cook /path/to/plan.md --advice

Full chain with --advice is under Advised feature chain; add --hard/--tdd/--html as optional modes

Easy start

Quick implement

Use when: Small feature or fix when requirements are already clear

~5–20 min · 3 steps

  1. 1
    /ak:cook "task"

    Implement

    Or /ak:cook --fast for the short path

  2. 2
    /ak:test Optional

    Verify

    Add when risk is more than a one-liner

  3. 3
    /ak:code-review Optional

    Review

    Add for shared or sensitive code

Optional: add --advice

/ak:cook "small task" --advice

Quick cook with --advice

Plan & advise

Advanced Go carefully

Advised feature chain

Use when: Multi-module features, large refactors, or important user-flow changes — pressure-test framing, then kongming checkpoints on plan/cook

~45–120 min · 7 steps

  1. 1
    /ak:advise "problem" Optional

    Pressure-test framing

    Optional

    • --agent — Claude Code only: run advisor on fable in an isolated context. On Codex this falls back to the normal inline path.

    Uses the model already selected in this session. Interview only — does not write code.

  2. 2
    /ak:plan --advice "…"

    Plan with kongming

    Optional

    • --hard — complex / multi-module / unfamiliar stack
    • --deep — large cross-area refactor
    • --tdd — tests-first phases for safer cook
    • --html — visual plan.html review

    Kongming gives advisory checkpoints — it does not replace your plan review.

  3. 3
    Review plan Your turn

    You still accept the plan before cook. If plan.html exists, review that for an easier visual pass.

  4. 4
    /ak:cook /path/to/plan.md --advice

    Implement with kongming

    Optional

    • --tdd — match plan if you used --tdd there — tests-first per phase
    • --auto — auto-approve gates — use carefully on high-risk work

    Pass the real plan path. Cook already runs tester + code-reviewer.

  5. 5
    /ak:test "scope" Optional

    Independent test gate

    Only when you want a final scope check beyond cook

  6. 6
    /ak:code-review --pending Optional

    Independent review gate

    Optional pending review before ship

  7. 7
    /ak:ship

    Open PR

    Creates PR; then watch CI → merge → target CI

Optional: add --advice

/ak:advise "problem"/ak:advise "problem" --agent/ak:plan --advice "…"/ak:cook /path/to/plan.md --advice

Inline advise = main model · --agent = advisor/fable (Claude Code only; Codex → inline) · plan/cook --advice = kongming · add optional modes as needed

Notes Click to read the notes
  • Skip /ak:advise when framing is solid — inline uses the main session model, not kongming
  • --agent is fully supported on Claude Code only (advisor/fable + AskUserQuestion relay); on Codex it falls back to inline
  • --hard --advice is expensive (research + red-team + kongming after gates) — keep for high-risk work
  • Put --tdd on plan when you want tests-first phases; pass the same --tdd to cook to match
  • Optional --html on plan when you want visual plan.html review before accepting
  • cook already runs tester + code-reviewer; extra /ak:test and /ak:code-review are optional independent gates
  • /ak:ship opens a PR — not proof of merge or green CI
Advanced Go carefully

Plan with gates

Use when: Plans for architecture, database, public API, payment, or security — red-team and validate before cook

~30–60 min · 6 steps

  1. 1
    /ak:predict Optional

    Debate approaches

    Multi-persona check before planning

  2. 2
    /ak:plan

    Hard or deep plan

    Optional

    • --hard — complex work needing research + red-team
    • --deep — large cross-area refactor
    • --tdd — tests-first phases
    • --html — visual plan.html review
    • --advice — kongming checkpoints mid-plan

    Pick a mode that fits risk — then run gates before cook

  3. 3
    /ak:plan red-team Optional

    Red-team plan

    If not already auto-run

  4. 4
    /ak:plan validate

    Validate plan

    Consistency / readiness gate

  5. 5
    Review plan Your turn

    Accept before cook. If plan.html exists, review that for an easier visual pass.

  6. 6
    /ak:cook /path/to/plan.md

    Implement

    Optional

    • --tdd — match plan if you used --tdd there
    • --advice — kongming checkpoints during implement

    After you accept; pass the plan path

More

More workflows coming soon

We unlock common workflows gradually. More recipes (bugs, review, ship…) will appear here over time.

Avoid traps

Common mistakes — try this instead

  • Common habit

    A long chain for a one-file tweak

    Better

    One quick /ak:cook --fast (or the domain skill you already know)

  • Common habit

    Skip review on login or payments

    Better

    Keep security + review steps for auth and money paths

  • Common habit

    Ship before tests pass

    Better

    Test (and review when risk is high) before /ak:ship

  • Common habit

    Jump to a new plan without new facts

    Better

    Fix the broken step, then continue the chain

  • Common habit

    Call a skill that is not installed

    Better

    Check the skills list, or run /ak:find-skills first

  • Common habit

    Mix up /ak:advise, --agent, and --advice

    Better

    /ak:advise = main model · --agent = advisor/fable · plan/cook --advice = kongming

  • Common habit

    Add --advice to every tiny edit

    Better

    Use it when the decision is hard or the blast radius is big

  • Common habit

    Always chain cook → test → code-review → ship

    Better

    cook already runs tester + reviewer; extra gates only when you want an independent check

Explore next