The Brainstorm → Plan → Cook → Ship AI Dev Workflow (with AgentKit)

by Jasmine, a developer who runs this exact brainstorm-plan-cook-ship loop with Claude Code and AgentKit on real production work.

Most "AI coding tips" articles hand you a pile of prompts and wish you luck. That's not a workflow - it's a bag of tricks. What actually moves the needle is a repeatable pipeline: the same phases, in the same order, with a verification gate at every stop. This is that pipeline, run end-to-end on one real feature, with the exact commands for each phase.

Which AgentKit? (not OpenAI AgentKit)

Quick disambiguation, because the name collides. The AgentKit in this article is the kit for Claude Code at agentkit.best (20% off via link) - a bundle of skills, agents, and slash commands you drive through the ak CLI. It was formerly "Claude Kit" (the ck CLI was renamed to ak).

It is not OpenAI AgentKit (Agent Builder, ChatKit, and the Connector Registry), launched on 6 October 2025. Same word, completely different product. If you landed here looking for OpenAI's tool to build chat agents, this isn't it - this is about a disciplined coding workflow on top of Claude Code. New to Claude Code entirely? Start here first.

Why a named workflow beats ad-hoc prompting

When you just chat your way through a feature, three failure modes show up on repeat. First, context fills up - by the time Claude is deep in implementation, it has forgotten half of what you agreed on early. Second, Claude "looks done" without verifying: it reports success, you run the code, and it doesn't work. Third, scope drifts - you asked for a rate limiter and got a rate limiter plus a refactor of three unrelated files.

The fix is a pipeline that separates thinking from doing, and gates every stop with a check. Anthropic's own guidance points the same direction: their Claude Code best-practices docs (accessed 2026-08-09) recommend an explore → plan → code → commit loop and, critically, tell you to "give Claude a way to verify" its output. Brainstorm-plan-cook-ship is the operational upgrade to that advice: instead of remembering to prompt each phase by hand, you make each phase a command with a defined artifact and a defined gate. Same principles, less discipline required from you, more consistency in what comes out. That's what makes it a repeatable AI coding workflow rather than a lucky session.

There's a second, subtler payoff: each named phase is a natural context boundary. Brainstorm produces a short outcome, not a transcript; plan produces a file you can hand to a fresh session; cook works from that file; ship reviews in a clean context. Because each phase hands off a small, durable artifact instead of a bloated conversation, you sidestep the "context fills up" failure entirely - the model that cooks never has to remember the whole brainstorm, only the plan it was given. Ad-hoc prompting can't do this, because everything lives in one ever-growing thread.

The 4 phases at a glance

Here is the whole loop in one table - what each phase produces, the command, and the gate that has to pass before you move on. Everything below is just this table expanded with real runs.

Phase 1 - Brainstorm: lock the outcome before touching code

The goal of brainstorm is boring on purpose: turn fuzzy intent ("add login") into an accepted outcome with acceptance criteria, and compare a couple of approaches before anyone writes a line. Skipping this is why so many AI sessions produce confident, wrong code - the model optimized for a target you never actually agreed on.

With AgentKit, run:

/ak:brainstorm add a Google OAuth callback route to the API

It interviews you: what "done" means, constraints, non-goals, and the acceptance criteria. You end with a short written outcome you actually signed off on - not a wall of code.

The raw Claude Code equivalent is plan mode. Start the session read-only so it can't edit anything while you think:

claude --permission-mode plan
# or toggle plan mode mid-session with Shift+Tab

Then prompt it to interview you before proposing anything: "Ask me clarifying questions until you can state the outcome and acceptance criteria, then stop." The difference is that AgentKit ships this as a repeatable command with a consistent output shape; raw Claude Code makes you drive the interview yourself each time.

Decision rule for this phase: if you can't say what "done" looks like in one sentence, you are not ready to plan, let alone cook.

Phase 2 - Plan: turn the outcome into a spec

Plan converts the accepted outcome into a written, self-contained spec: the files you'll touch, the interfaces, what's explicitly out of scope, and - the part everyone skips - how the change will be verified end to end. A precise plan pays off far more than watching implementation scroll by, because a good plan is the thing you actually review; the code just follows it.

/ak:plan implement the OAuth callback per the brainstorm outcome

AgentKit produces a phased plan file you can read, edit, and keep. When the plan needs to understand unfamiliar code first, it delegates the research to a scout subagent so your main context stays clean:

/ak:scout # investigates the codebase, reports back without editing

If you're fuzzy on why a subagent handles the scouting instead of the main agent - or how skills, hooks, and MCP fit around it - I broke down the pieces in skills vs subagents vs hooks vs MCP. In raw Claude Code, you get the same effect from plan mode plus editing the proposed plan inline (use Ctrl+G to open it in your editor) before you let it proceed.

This is spec-driven development in miniature: write the spec, agree on it, and the implementation becomes a checklist instead of a guessing game. The tell that your plan is good enough to cook from is simple - a different engineer (or a fresh Claude Code session) could execute it without asking you a single question. If it still needs your running commentary to make sense, it isn't a plan yet; it's a rough idea, and cooking from a rough idea is how scope drifts.

Phase 3 - Cook: implement with verification gates

Cook is where code gets written - but the whole point is that the loop closes on a passing check, not on Claude saying "done." You execute the plan and pair it with tests so every stop is gated.

/ak:cook # implements the approved plan, phase by phase
/ak:test # runs the test suite; failures feed back into the loop

The pattern that matters: give the model a way to prove the change works before it declares victory. That means running the tests, running the build, or diffing a screenshot - with the output visible. If you use raw Claude Code, wire the same gate with a Stop hook or the /goal command so the session can't call itself finished until a concrete condition passes.

Two habits keep cook from going off the rails. Course-correct early - hit Esc to interrupt a wrong turn, or /rewind to back up - rather than letting it dig a deeper hole. And run /clear between unrelated tasks so stale context doesn't bleed into the next change. For anything gnarly (a flaky test, an unfamiliar bug), spin off a subagent to investigate so the main thread stays focused on shipping the feature.

Phase 4 - Ship: review, then PR

Here's the rule that upgrades ship from "commit and hope" to something you'd trust on a team: the reviewer that grades the work is not the one that wrote it. A model that just spent an hour convincing itself the code is correct is the worst possible judge of that code. So you review in a fresh context first.

/ak:code-review # a fresh reviewer grades the diff against the plan

This spins up an adversarial pass - a reviewer subagent (or a clean session) that reads the diff against the original plan and looks for regressions, missed acceptance criteria, and sloppy edges. Only after it signs off do you open the PR:

/ak:ship # conventional commit + PR via gh

AgentKit writes a conventional commit and opens the pull request through the gh CLI. The raw equivalent is running /code-review in a new session, then gh pr create yourself. Optionally close the loop with /ak:journal to capture the decisions you made - future-you will thank present-you when you revisit why the callback was built this way.

The full loop on one real feature (end-to-end)

Let's put it together on one small, real feature: adding a Google OAuth callback route to an existing API. Here are the four artifacts, side by side, the way they actually stack up in a run.

1. Brainstorm → a two-line outcome: "Add GET /auth/google/callback that exchanges the code for tokens, creates/links the user, and sets a session cookie. Non-goals: no refresh-token rotation, no new UI." Acceptance: a new integration test passes and a manual login round-trips.
2. Plan → a phased plan file: which route file, the token-exchange helper, the session module it reuses, error handling for a denied consent, out-of-scope list, and the exact test to write.
3. Cook → the diff: the new route, the helper, one new integration test, wired to the existing session code - with the test run passing before it stops.
4. Ship → a fresh review catches one thing (the denied-consent path returned a 500 instead of redirecting), that gets fixed, then a conventional commit and PR open.

On time: the visible savings aren't from the model typing faster - they're from not redoing work. Because the outcome was locked in phase 1 and the plan was reviewed in phase 2, the cook in phase 3 rarely wanders, and the phase-4 review catches the one real defect before it ever reaches a human reviewer or CI. The expensive loop in ad-hoc coding - build the wrong thing, discover it late, unwind it - is exactly what the gates prevent. A feature this size might have taken a couple of scattered sessions of prompt-and-pray; run through the pipeline it's one focused pass with a clean PR at the end.

Honest note on where the human still matters: the model never decides the outcome - I do, in phase 1 - and the review catch in phase 4 is exactly the kind of judgment call you don't want to fully automate. The workflow removes the busywork and the "looks done" traps; it does not remove you.

When to skip phases (don't over-process a typo)

This framework earns its keep on multi-file, unfamiliar, or uncertain-approach work. It's overkill for a one-line fix. The decision rule I use:

If you can describe the entire diff in one sentence, skip brainstorm and plan - go straight to cook. Fixing a typo, bumping a version, renaming a variable: just do it (and still let a test confirm nothing broke).

Reach for the full pipeline when any of these are true: the change spans several files, you don't know the codebase area well, there's more than one reasonable approach, or a mistake is expensive to undo. The whole art is matching process weight to risk - a heavy process on a trivial change is its own kind of waste.

AgentKit vs doing this with plain Claude Code

Let me be clear, because this is where honesty matters: you do not need AgentKit to run this workflow. Brainstorm-plan-cook-ship works with raw Claude Code. You can build your own slash commands, write your own skills, and wire your own Stop hooks to reproduce every gate described above. Plenty of good developers do exactly that.

What AgentKit gives you is the pre-built, opinionated version: the /ak:* commands, 108+ skills, and 45 agents (17 engineer + 28 marketing) already assembled and tested, so you skip the weeks of building and maintaining your own kit. It also works with GitHub Copilot, not just Claude Code. Who needs it: people who want the workflow now and would rather not become a part-time tooling author. Who doesn't: people who enjoy building their own command library, or whose needs are narrow enough that two custom commands cover it. If you're weighing options, I compared it against the field in how AgentKit compares to alternatives.

Limitations & honest take

No tool is free of trade-offs, and pretending otherwise would defeat the point of this article.

• Learning curve. You still need to know Claude Code first. AgentKit accelerates a workflow; it doesn't teach you the fundamentals. If Claude Code itself is new to you, learn that before layering a kit on top.
• Pricing is in USD and is a real cost: the Engineer Kit and Marketing Kit are $99 each, the bundle is $149 (the site lists no recurring fee for the kits), and there's a money-back guarantee - though the site doesn't state a specific duration, so don't assume one.
• Subscription vs one-time confusion. The kits are one-time; the separate Desktop App is a yearly subscription ($19/yr). Easy to mix up - read the checkout carefully.
• Some overlap. A few skills duplicate things you may already script yourself. The value is in the curation and the workflow glue, not every single skill being novel.

FAQ

What is the brainstorm-plan-cook-ship workflow?

It's a repeatable four-phase AI dev workflow: brainstorm (lock the outcome and acceptance criteria), plan (write a self-contained spec), cook (implement plus tests until they pass), and ship (an adversarial review in a fresh context, then open a PR). It operationalizes Anthropic's explore-plan-code-commit advice into named commands with a verification gate at every phase.

Do I need AgentKit to use this workflow?

No. The workflow runs on plain Claude Code - you'd build your own slash commands, skills, and Stop hooks to get the same gates. AgentKit is the pre-built version that ships those commands (/ak:brainstorm, /ak:plan, /ak:cook, /ak:ship) so you don't have to assemble them yourself.

Is AgentKit the same as OpenAI AgentKit?

No. This AgentKit is the kit for Claude Code at agentkit.best, driven by the ak CLI (formerly Claude Kit / ck). OpenAI AgentKit is a different product (Agent Builder, ChatKit, Connector Registry) launched on 6 October 2025. Same name, unrelated tools.

What are the exact commands for each phase?

Brainstorm: /ak:brainstorm. Plan: /ak:plan (with /ak:scout for codebase research). Cook: /ak:cook plus /ak:test. Ship: /ak:code-review then /ak:ship, with an optional /ak:journal to capture decisions.

Does it work with GitHub Copilot too?

Yes. AgentKit supports both Claude Code and GitHub Copilot, so the same workflow structure is available if your team is on Copilot rather than Claude Code.

Is AgentKit one-time or a subscription?

The kits (Engineer $99, Marketing $99, bundle $149) are one-time - the site lists no recurring fee for them and includes lifetime kit updates. The separate Desktop App is a yearly subscription ($19/yr). They're billed differently, so check what you're actually buying.

Conclusion + get the kit

That's the whole loop: brainstorm to lock the outcome, plan to write the spec, cook to implement behind a passing test, and ship after a fresh reviewer signs off. Named phases, one command each, a gate at every stop - that's what turns lucky sessions into a repeatable AI dev workflow. Run it with raw Claude Code, or skip the assembly and use the pre-built commands.

Want the full breakdown before you buy? Read what AgentKit includes first.