test-kitchen
Parallel implementation framework. Omakase-off triggers FIRST on build/create requests (wraps brainstorming). Cookoff triggers at design→implementation transition (wraps execution). Together they provide entry and exit gates for the Test Kitchen workflow.
When & Why to Use This Skill
Test Kitchen is a high-performance parallel implementation framework designed to optimize the transition from design to code. By utilizing dual-gate orchestration—'Omakase-off' for design exploration and 'Cookoff' for implementation—it allows users to explore multiple architectural paths and code variants simultaneously. This skill effectively eliminates technical indecision and ensures optimal project outcomes through automated parallel prototyping and competitive implementation.
Use Cases
- Architectural Exploration: When unsure about the best tech stack or design pattern, use Omakase mode to generate and compare 3-5 different architectural approaches in parallel.
- Competitive Implementation: Use the Cookoff gate to have multiple agents implement the same design doc independently, allowing you to pick the most efficient or cleanest code result.
- Resolving Brainstorming Deadlocks: Automatically trigger parallel exploration when a user expresses uncertainty (e.g., 'not sure', 'either works') regarding critical technical decisions.
- Rapid Prototyping: Short-circuit lengthy brainstorming sessions by moving directly from a build request to multiple working code variants to see which one performs best in practice.
- Complex Feature Handoff: Streamline the workflow from design to execution by using the 'exit gate' to ensure implementation only begins once the design is finalized and validated.
| name | test-kitchen |
|---|---|
| description | This skill should be used when implementing features with parallel exploration or competition. Triggers on "build", "create", "implement", "try both approaches", "compare implementations". Routes to omakase-off (entry gate for design exploration) or cookoff (exit gate for parallel implementation). |
Test Kitchen
Parallel implementation framework with two gate skills:
| Skill | Gate | Trigger |
|---|---|---|
test-kitchen:omakase-off |
Entry | FIRST on any build/create/implement request |
test-kitchen:cookoff |
Exit | At design→implementation transition |
Flow
"Build X" / "Create Y" / "Implement Z"
↓
┌─────────────────────────────────────┐
│ OMAKASE-OFF (entry gate) │
│ Wraps brainstorming │
│ │
│ Choice: │
│ 1. Brainstorm together │
│ 2. Omakase (3-5 parallel designs) │
└─────────────────────────────────────┘
↓
[Brainstorming / Design phase]
↓
Design complete, "let's implement"
↓
┌─────────────────────────────────────┐
│ COOKOFF (exit gate) │
│ Wraps implementation │
│ │
│ Choice: │
│ 1. Cookoff (2-5 parallel agents) │
│ 2. Single subagent │
│ 3. Local implementation │
└─────────────────────────────────────┘
↓
[Implementation]
Key Insight
Skills need aggressive triggers to work. They can't passively detect "uncertainty" or "readiness" - they must claim specific moments in the conversation flow.
- Omakase-off: Claims the BUILD/CREATE moment (before brainstorming)
- Cookoff: Claims the IMPLEMENT moment (after design)
When Each Triggers
Omakase-off (Three Triggers)
Trigger 1: BEFORE brainstorming
- "I want to build...", "Create a...", "Implement...", "Add a feature..."
- ANY signal to start building something
- Offers choice: Brainstorm together OR Omakase (parallel designs)
Trigger 2: DURING brainstorming (slot detection)
- 2+ uncertain responses on architectural decisions
- "not sure", "don't know", "either works", "you pick", "no preference"
- Offers to explore detected slots in parallel
Trigger 3: Explicitly requested
- "try both approaches", "explore both", "omakase"
- "implement both variants", "let's see which is better"
Cookoff
- "Let's implement"
- "Looks good, let's build"
- "Ready to code"
- Design doc just committed
- ANY signal to move from design to code
Omakase Mode (Skip Brainstorming)
If user picks "Omakase" at the entry gate:
- Quick context gathering (1-2 questions)
- Generate 3-5 best architectural approaches
- Implement ALL in parallel
- Tests pick the winner
- Skip detailed brainstorming entirely
Best for: "I'm flexible, show me options in working code"
Cookoff Mode (Parallel Implementation)
If user picks "Cookoff" at the exit gate:
- Each agent reads the same design doc
- Each agent creates their OWN implementation plan
- All implement in parallel
- Compare results, pick winner
Best for: "I want to see different implementation approaches"
Key Distinction
| Omakase-off | Cookoff | |
|---|---|---|
| Gate | Entry (before/during brainstorming) | Exit (after design) |
| Question | HOW to explore? | HOW to implement? |
| Parallel on | Different DESIGNS | Same design, different PLANS |
| Triggers | Build request, indecision detection, explicit | "let's implement" signal |
| Skips | Brainstorming (optional via short-circuit) | Nothing - always after design |
Slot Detection (During Brainstorming)
When omakase-off delegates to brainstorming, it passively tracks architectural decisions where user shows uncertainty:
Detection signals:
- "not sure", "don't know", "either works", "both sound good"
- "you pick", "whatever you think", "no preference"
- User defers 2+ decisions in a row
Slot classification:
| Type | Examples | Worth exploring? |
|---|---|---|
| Architectural | Storage engine, framework, auth method | Yes - different code paths |
| Trivial | File location, naming, config format | No - easy to change |
At end of brainstorming:
- If architectural slots exist → offer parallel exploration
- If no slots → hand off to cookoff for implementation