home / skills / jjuidev / jss / cook

cook skill

/.claude/skills/cook

This skill automates end-to-end feature implementation in Python by guiding research, planning, coding, testing, and finalizing with smart intent detection.

npx playbooks add skill jjuidev/jss --skill cook

Review the files below or copy the command above to add this skill to your agents.

Files (6)
SKILL.md
3.2 KB
---
name: cook
description: ALWAYS activate this skill before implementing EVERY feature, plan, or fix.
version: 2.1.0
---

# Cook - Smart Feature Implementation

End-to-end implementation with automatic workflow detection.

**Principles:** YAGNI, KISS, DRY | Token efficiency | Concise reports

## Usage

```
/cook <natural language task OR plan path>
```

**Optional flags:** `--fast`, `--parallel`, `--no-test`, `--auto`

Example:
```
/cook "Add user authentication to the app" --fast
/cook path/to/plan.md --auto
```

## Smart Intent Detection

| Input Pattern | Detected Mode | Behavior |
|---------------|---------------|----------|
| Path to `plan.md` or `phase-*.md` | code | Execute existing plan |
| Contains "fast", "quick" | fast | Skip research, scout→plan→code |
| Contains "trust me", "auto" | auto | Auto-approve all steps |
| Lists 3+ features OR "parallel" | parallel | Multi-agent execution |
| Contains "no test", "skip test" | no-test | Skip testing step |
| Default | interactive | Full workflow with user input |

See `references/intent-detection.md` for detection logic.

## Workflow Overview

```
[Intent Detection] → [Research?] → [Review] → [Plan] → [Review] → [Implement] → [Review] → [Test?] → [Review] → [Finalize]
```

**Default (non-auto):** Stops at `[Review]` gates for human approval before each major step.
**Auto mode (`--auto`):** Skips human review gates, implements all phases continuously.

| Mode | Research | Testing | Review Gates | Phase Progression |
|------|----------|---------|--------------|-------------------|
| interactive | ✓ | ✓ | **User approval at each step** | One at a time |
| auto | ✓ | ✓ | Auto if score≥9.5 | All at once (no stops) |
| fast | ✗ | ✓ | User approval at each step | One at a time |
| parallel | Optional | ✓ | User approval at each step | Parallel groups |
| no-test | ✓ | ✗ | User approval at each step | One at a time |
| code | ✗ | ✓ | User approval at each step | Per plan |

## Step Output Format

```
✓ Step [N]: [Brief status] - [Key metrics]
```

## Blocking Gates (Non-Auto Mode)

Human review required at these checkpoints (skipped with `--auto`):
- **Post-Research:** Review findings before planning
- **Post-Plan:** Approve plan before implementation
- **Post-Implementation:** Approve code before testing
- **Post-Testing:** 100% pass + approve before finalize

**Always enforced (all modes):**
- **Testing:** 100% pass required (unless no-test mode)
- **Code Review:** User approval OR auto-approve (score≥9.5, 0 critical)
- **Finalize:** project-manager AND docs-manager must complete

## Required Subagents

| Phase | Subagent |
|-------|----------|
| Research | `researcher` (parallel, optional in fast) |
| Scout | `scout` |
| Plan | `planner` |
| UI Work | `ui-ux-designer` |
| Testing | `tester`, `debugger` |
| Review | `code-reviewer` |
| Finalize | `project-manager`, `docs-manager`, `git-manager` |

## References

- `references/intent-detection.md` - Detection rules and routing logic
- `references/workflow-steps.md` - Detailed step definitions for all modes
- `references/review-cycle.md` - Interactive and auto review processes
- `references/subagent-patterns.md` - Subagent invocation patterns

Overview

This skill enforces a consistent, end-to-end feature implementation workflow and must be activated before designing or changing any feature, plan, or fix. It detects intent from natural language or plan files and orchestrates research, planning, implementation, testing, review, and finalization with configurable modes like auto, fast, parallel, and no-test.

How this skill works

The skill inspects the input string or path and applies intent-detection rules to pick a mode (interactive, auto, fast, parallel, code, no-test). It then invokes a sequence of subagents (researcher, planner, ui-ux-designer, tester, code-reviewer, project-manager, docs-manager, git-manager) following the workflow steps and review gates. Modes control whether research runs, whether human review gates are enforced, and whether steps run in parallel or sequentially.

When to use it

  • Before starting any new feature, fix, or architectural change
  • When converting a written plan (plan.md or phase-*.md) into code
  • For sprint tasks that need consistent review and test gating
  • When you want automated full-run execution (--auto) or expedited runs (--fast)
  • When coordinating multi-agent or parallel tasks (use --parallel)

Best practices

  • Always run the skill first to ensure workflow compliance and traceability
  • Provide clear intent keywords or a plan path to get the correct mode (e.g., 'fast', 'auto', or path/to/plan.md)
  • Use --auto only when confident in automated approvals and quality scoring
  • Reserve --no-test only for experimental branches; production requires tests
  • Keep plans concise and phase-oriented so the code mode can execute them directly

Example use cases

  • /cook "Add user authentication to the app" --fast to skip research and get an expedited implementation plan
  • /cook path/to/plan.md to execute an existing plan file end-to-end with review gates
  • /cook "Add three payment methods" --parallel to run subagents concurrently on independent features
  • /cook "Refactor payment module" --auto to run research, plan, implementation, and tests without human review when confidence is high
  • /cook "Hotfix: critical bug" --no-test for an emergency branch where tests are temporarily skipped

FAQ

What happens if the auto score is low?

Auto mode will only auto-approve when the confidence score meets the configured threshold; otherwise it falls back to interactive review gates.

Can I customize which subagents run?

You can influence which subagents are used via mode flags and by supplying a plan; core subagents are required for compliance but optional ones (like researcher in fast) may be skipped.