A full-stack implementer workflow that emphasizes coding with real tests and review, following a structured lifecycle from Clarify to Report.

When should I use cook?

When building features that require coding, tests, and formal review; when multi-file changes or planning are needed; when you want gate-based progression and test-driven quality.

How does gating work?

GATE steps require user confirmation to start and to proceed; tests must pass (via /test) before moving to the next phase.

cook

npx machina-cli add skill Vibe-Builders/claude-prime/cook --openclaw

Files (1)

SKILL.md

1.5 KB

Ultrathink.

Role

You are a full-stack implementer. Your job is to BUILD with proper testing and review.

Lifecycle

Before starting, check conversation context and skip completed steps.

1. Clarify (if needed)

Confirm requirements and acceptance criteria
Ask clarifying questions if anything is unclear

GATE: User confirms before proceeding.

2. Research (if needed)

Execute /research for codebase context and patterns

3. Plan (if needed)

Execute /give-plan for multi-file or architectural changes
Skip for obvious single-file modifications or simple tasks

GATE: User approves plan before implementation.

4. Implement

Write code following existing patterns
Make small, focused changes

5. Test & Fix

Execute /test on implemented files
If FAIL → use /fix to address failures, re-test
After 3 attempts, ask user for guidance
For frontend/UI changes: may use browser skill to verify

GATE: Tests pass before proceeding.

6. Review

Execute /review-code on changes
Address critical issues if found

7. Report

Files changed (with brief description)
Tests added/modified
Key decisions made
Any follow-up items

Constraints

Real tests, no fake data
Follow existing patterns
Don't over-engineer

Request

<request>$ARGUMENTS</request>

Source

git clone https://github.com/Vibe-Builders/claude-prime/blob/main/.claude/skills/cook/SKILL.mdView on GitHub

Overview

cook is a full-stack implementer workflow that builds features with proper testing and review. It guides development from Clarify through Research, Plan, Implement, Test & Fix, Review, and Report to ensure changes are well-scoped and quality-checked.

How This Skill Works

It uses a structured lifecycle: Clarify requirements (GATE), optionally Research, then Plan changes. Implement small, focused code changes, run tests with /test and fix failures with /fix, and complete a code review with /review-code before Reporting. Key gates require user confirmation to begin and to proceed, and tests must pass before continuing.

When to Use It

When building features that require coding plus tests and review
When adding functionality aligned with existing patterns
When making changes that need a formal plan or multi-file updates
When preparing a PR with plan, test suite, and review
When ensuring real tests and code-quality checks before release

Quick Start

Step 1: Clarify requirements and acceptance criteria
Step 2: Implement small changes and run /test; fix as needed
Step 3: Iterate through /review-code, then /report with a summary

Best Practices

Get user confirmation (GATE) on requirements before coding
Keep changes small and focused to simplify review
Follow project conventions and testing patterns
Write meaningful tests that cover new or modified behavior
Document decisions and outcomes in the Report and PR notes

Example Use Cases

Add a new REST endpoint with unit and integration tests
Refactor a module with tests and a fresh code review
Introduce a feature flag with tests and acceptance criteria
Fix a bug with targeted tests and a peer review
Submit a PR that includes a plan, tests, and review comments

Frequently Asked Questions

Add this skill to your agents