Grill Me workflow guide · 7 min read
Kanban for Grill Me: scale planning across agents
Break a complex idea into clear tasks. Plan each in its own session, then deliver them in dependency order.
Tao Wu · Founder of AI4KanbanOn this page
- What are grill-me and grill-with-docs?
- Why put Grill Me on a Kanban?
- Does every card investigate before asking questions?
- Can agents answer product decisions autonomously?
- Is this still Kanban if the visual board is optional?
- How do multiple agents work without repeating each other?
- What does the human actually read?
Matt Pocock's grill me workflow stress-tests a plan through focused questions until its decision tree is resolved. It researches answers available in the codebase, gives a recommendation with each genuine decision, and turns a vague idea into shared understanding.
A complex idea does not have to stay in one plan. AI4Kanban uses one session to split it into cards with clear outcomes and boundaries. A planning agent then works through each card in its own session, investigating the task and asking the questions it needs. One card is one focused Grill Me-style planning exercise; dependencies and project memory connect those cards into a project.
Closely related cards that serve one larger goal can form a group task, with a parent card for the whole piece of work. Tasks that are separate pieces of work can remain standalone cards.
For parts you want to control precisely—UI, copy, video scripts, and more—specialist agents prepare drafts for you to review. The approved version is what agents must deliver. They can work out the other details within the task's scope.
What are grill-me and grill-with-docs?
grill-me is a planning interview. The agent walks through the decisions behind an idea, one branch at a time, and investigates the repository instead of asking you factual questions it can answer itself.
grill-with-docs combines that interview with durable domain documentation and architecture decision records.
AI4Kanban starts from the same principle and keeps the same unit of work.
| Layer | What it adds |
|---|---|
grill-me | Investigates and resolves 1 plan |
grill-with-docs | Keeps domain documentation and decision records current while resolving that plan |
| An AI4Kanban card | Gives 1 task its own planning session and durable plan, then adds drafts, dependencies, priority, modules, todos, notable answers, and delivery state |
The initial session establishes the task boundaries and dependencies. The planning sessions on individual cards fill in the details for those tasks. Each plan has a focused context, while project memory keeps earlier decisions available.
Why put Grill Me on a Kanban?
In a Claude Code conversation, you may keep a large idea and all its questions in one plan. As unrelated tasks accumulate, it becomes harder for both you and the agent to tell which details matter to each task.
AI4Kanban separates the initial breakdown from detailed planning. First, split the idea into cards. Then let the planning agent work through each card in its own session. A narrower task keeps its questions and assumptions together, so the agent can ask more focused questions and you can judge one piece of work at a time.
The board records how those cards relate:
| Card field | What it controls |
|---|---|
| Dependencies | Which prerequisites must be delivered first, and which cards can run together |
| Priority | Which unblocked work should be prepared or delivered next |
| Modules | Which product areas the card changes, and which memory topics apply |
| Todo | What must be true before the card is complete |
One specification
A coordinated task graph
Does every card investigate before asking questions?
Yes. Like grill-with-docs, AI4Kanban expects the agent to investigate before it asks.
The agent reads the card, repository, product description, related work, and relevant project memory. It settles factual questions from evidence, fills in routine implementation detail, and tests the requirement for missing outcomes, boundaries, edge cases, dependencies, and verification criteria.
Only a decision that cannot be settled from project evidence should become a question. The card then carries concrete options, the outcome and cost of each option, and the agent's recommendation.
Can agents answer product decisions autonomously?
Yes. AI4Kanban does not require a person to answer every question merely because it concerns the product.
When project evidence supports a safe choice, the agent answers it and continues. If that answer materially changes behavior, scope, risk, privacy, compatibility, or ongoing cost, the card records it under Worth noting for review. The decision is visible without blocking the task.
| Finding | What AI4Kanban does |
|---|---|
| Fact available in the project | Researches and answers it |
| Routine or reversible decision | Chooses a safe default and continues |
| Consequential decision with enough evidence | Answers it, records it under Worth noting, and continues |
| Consequential decision without enough evidence | Leaves a user-owned question with options and a recommendation |
| Result that only a person or external environment can judge | Adds a reproducible human verification step |
This keeps autonomy high without hiding meaningful product calls. The human reviews the decisions worth noticing instead of serving as the answer engine for every card.
Is this still Kanban if the visual board is optional?
Yes. Here, Kanban is a project-management method for turning a vague idea into actionable work. The visual board is one interface, not the source of the method.
Traditional boards are designed mainly to help people scan status. AI4Kanban's board is also read and updated by agents. Its Markdown cards make outcomes, dependencies, questions, decisions, modules, and todos explicit enough for either side to continue the work.
The result is a shared workspace where:
- Agents can discover ready work without waiting for a fresh prompt.
- Humans can inspect a bounded requirement instead of an agent's entire conversation.
- Another agent can review the same card independently.
- Project state survives context compaction, stopped sessions, and model changes.
How do multiple agents work without repeating each other?
The initial breakdown gives each card an outcome and a clear boundary. Its planning agent focuses on that task's questions without carrying every other task's discussion through the same conversation.
For a group task, the parent card supplies the shared goal and requirements to its child cards. Each child's planning session uses that parent context alongside relevant project memory, while keeping its own task discussion focused. Standalone cards use relevant project context without needing a group.
Dependencies stop a card from proceeding before its prerequisites are delivered. Independent coding tasks can run in isolated Git worktrees, with each card retaining its own requirements and progress.
Project memory carries forward shipped behavior, current decisions, rejected directions, and design lessons. Later cards receive that memory instead of replaying every earlier conversation.
This addresses a recurring problem in documented grilling workflows: users have reported important interview decisions missing from an ADR and rationale being lost when a grilling session becomes a specification. AI4Kanban keeps the approved requirement and notable answers on the card, then promotes reusable decisions into project memory.
Settled answers to cards' open questions, grouped by topic.
- Guest checkout: an email is enough; no account before the first order.
- One page: address, shipping and payment stay on one screen.
- Currency: prices show in the buyer's own currency, fixed at order time.
What does the human actually read?
Not a full specification and not a PRD. Each card is split into a short human half and a folded agent half.
| Card half | What it contains |
|---|---|
| Human half | The task summary, drafts for the parts you want to control, genuine open questions, Worth noting decisions made during planning, and Worth noting after implementation decisions surfaced while building |
| Agent half | Current behavior, detailed scope, todos, routine agent decisions, specialist work, and sources needed to implement and review the task |
Review the brief, the drafts, and the decisions that need your judgment. Once approved, the drafts are exact requirements for those parts of the task; agents handle the remaining details within the agreed scope. The folded agent half carries the implementation detail.
You approve the drafts and answer unresolved product choices, then let agents deliver the task. Questions and draft approvals appear in the app, with Cloud providing Slack notifications where available. A card waiting for judgment does not stop unrelated cards from moving.
Frequently asked questions
How is AI4Kanban different from running grill-with-docs once?
A standalone planning conversation can work through one plan. AI4Kanban first breaks a larger idea into bounded task cards, then gives each card its own planning session. Project memory carries decisions from earlier cards into later ones; dependencies set the delivery order, and priority picks the next unblocked card.
Does AI4Kanban replace Grill Me?
Yes. AI4Kanban instruments Grill Me's planning process as a durable card: a larger idea is split into cards first, and each card gets a planning session of its own. The board then adds a GUI, autonomous research and decisions, dependencies, project memory, specialist and review runs, notifications, and multi-agent delivery, across coding and marketing work.
Does AI4Kanban replace traditional spec-driven development?
Often yes; in a process that still requires formal specification documents, partly. Traditional spec-driven development produces long task specifications that take time for people to read even though an agent eventually consumes most of the detail.
AI4Kanban keeps implementation detail in the folded agent half of each card. You review the brief, important decisions, and the drafts that agents must follow; agents read the full requirements and deliver the task. A PRD may still define higher-level product goals; each card remains one bounded plan within that project.
What happens if I reject an agent-made product decision?
Revise the card and, where needed, its drafts before letting agents continue. The corrected requirements stay with the task, and reusable decisions can guide later cards.
Can other cards continue while one needs my answer?
Yes. Only the work that depends on that unanswered decision waits. Independent ready cards can continue through planning and delivery.