cook

name	cook
description	End-to-end feature builder that orchestrates the full lifecycle from planning through research, scouting, coding, testing, review, and shipping a feature.
layer	orchestrator
category	orchestration
triggers	["/cook","cook a feature","build this feature end to end","implement this feature completely","full feature build"]
inputs	["Feature description or user story","Optional acceptance criteria","Optional target branch or module","Optional priority level"]
outputs	["Completed, tested, reviewed feature code","Generated tests covering the feature","Code review summary with any resolved issues","Commit(s) ready to merge or ship"]
linksTo	["plan","research","scout","code-review","test","fix","refactor","optimize","sequential-thinking","git-workflow","commit-crafter","pr-writer","changelog-writer","docs-writer"]
linkedFrom	["team","kanban"]
preferredNextSkills	["ship","pr-writer","changelog-writer"]
fallbackSkills	["plan","debug"]
riskLevel	medium
memoryReadPolicy	selective
memoryWritePolicy	always
sideEffects	["Creates or modifies source files","Creates or modifies test files","Creates git commits","May create or update documentation"]

Cook

Purpose

Cook is the end-to-end feature builder orchestrator. It takes a feature request, user story, or task description and drives it through every stage of development -- from initial planning and research all the way through coding, testing, code review, and preparing to ship. Think of it as the "chef" that coordinates the entire kitchen: it delegates specialized work to hub and utility skills while maintaining the big picture.

Cook ensures that no step is skipped. Features built through Cook always have a plan, are informed by research, follow existing codebase patterns, include tests, pass review, and are commit-ready.

Workflow

Phase 1: Understand & Plan

1. Parse the request -- Extract the core feature, constraints, acceptance criteria, and scope from the user's input.
2. Invoke plan -- Generate a structured implementation plan with milestones, dependencies, and risk flags.
3. Invoke research (if needed) -- Look up library docs, API references, or patterns via Context7 or web search when the feature touches unfamiliar territory.
4. Invoke sequential-thinking (if complex) -- For multi-step logic or architectural decisions, use structured reasoning to resolve ambiguity before writing code.

Phase 2: Scout & Prepare

5. Invoke scout -- Scan the codebase for related files, existing patterns, naming conventions, and integration points. Identify where the new code should live and what it should conform to.
6. Summarize findings -- Present a brief to the user: "Here's the plan, here's what I found in the codebase, here's my approach." Wait for confirmation if the task is high-risk or ambiguous.

Phase 3: Implement

7. Write the code -- Implement the feature following the plan, adhering to patterns discovered by scout, and respecting all project guidelines (single responsibility, separation of concerns, DRY).
8. Invoke refactor (if needed) -- If existing code must be restructured to accommodate the feature cleanly, delegate refactoring to the refactor skill.
9. Invoke optimize (if needed) -- If the implementation has obvious performance concerns, run optimization passes.

Phase 4: Test

10. Invoke test -- Generate and run tests for the new feature. This includes unit tests, integration tests if applicable, and edge-case coverage.