home / skills / duc01226 / easyplatform / cook-auto

cook-auto skill

/.claude/skills/cook-auto

This skill analyzes tasks and automatically activates necessary subskills to implement features efficiently with evidence-backed changes.

npx playbooks add skill duc01226/easyplatform --skill cook-auto

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

Files (1)
SKILL.md
1.4 KB
---
name: cook-auto
description: "[Implementation] ⚡⚡ Implement a feature automatically (\"trust me bro\")"
argument-hint: [tasks]
infer: true
---

**Ultrathink** to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules:
<tasks>$ARGUMENTS</tasks>

**IMPORTANT:** Analyze the list of skills  at `.claude/skills/*` and intelligently activate the skills that are needed for the task during the process.
**Ensure token efficiency while maintaining high quality.**

## ⚠️ Anti-Hallucination Reminder

**Before modifying ANY code:** Verify assumptions with actual code evidence. Search for usages, read implementations, trace dependencies. If confidence < 90% on any change, investigate first or ask user. See `.claude/skills/shared/anti-hallucination-protocol.md` for full protocol.

## Workflow:
1. Trigger slash command `/plan <detailed-instruction-prompt>` to create an implementation plan based on the given tasks.
2. Trigger slash command `/code <plan>` to implement the plan.
3. Finally use `AskUserQuestion` tool to ask user if he wants to commit to git repository, if yes trigger `/commit` slash command to create a commit.

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

Overview

This skill automates implementing small-to-medium feature requests by planning, coding, and preparing commits with minimal supervision. It orchestrates a multi-step workflow that creates an implementation plan, applies code changes, and prompts the user to commit. The skill emphasizes verification of code evidence to avoid incorrect changes and conserves token usage while preserving quality.

How this skill works

The skill first analyzes available helper skills and project code to determine which tools and modules are needed. It generates a detailed implementation plan via a /plan command, then executes the plan with a /code command broken into many small todos. Before any edits, it verifies assumptions by searching usages and tracing dependencies. Finally, it asks whether to commit and, on confirmation, prepares a commit via the /commit command.

When to use it

  • You want a largely automated implementation of a clearly specified feature or bug fix.
  • You need a reproducible plan and incremental code changes for review.
  • You want assurance that changes are based on actual code evidence, not guesses.
  • You prefer small, reviewable commits and an explicit final review step.

Best practices

  • Provide a clear, detailed instruction prompt to /plan so the generated plan is precise.
  • Accept plans that break work into many small todos and include a final review task.
  • Allow the skill to inspect project code and helper skills before requesting changes.
  • If any assumption is uncertain, pause and ask clarifying questions rather than proceeding.
  • Limit scope per run to keep commits focused and maintain token efficiency.

Example use cases

  • Add a new endpoint and its unit tests with a stepwise plan and commit preparation.
  • Implement a UI form validation flow, breaking work into small tasks and verifying usages.
  • Refactor a module by planning granular changes, running safety checks, and reviewing diffs.
  • Apply a cross-cutting improvement (logging, error handling) across multiple files with evidence checks.

FAQ

How do you avoid making incorrect code changes?

I verify all assumptions by searching code usages, reading implementations, and tracing dependencies; if confidence is below 90%, I pause and ask for clarification.

Can I review changes before they are committed?

Yes. The skill produces a plan, implements code in small steps, and asks you to confirm before creating a commit.