home / skills / duc01226 / easyplatform / cook-fast

cook-fast skill

safe

This skill rapidly implements features in C# with minimal planning, leveraging prior knowledge to deliver working code fast.

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

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

Files (1)

SKILL.md

1.8 KB

---
name: cook-fast
description: "[Implementation] ⚡ Fast implementation - skip research, minimal planning"
argument-hint: [tasks]
infer: true
---

Start working on these tasks immediately with minimal planning:
<tasks>$ARGUMENTS</tasks>

**Mode:** FAST - Skip research, minimal planning, trust your knowledge.

## ⚠️ 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. **Quick Planning** (skip research phase)
   - Analyze task requirements directly
   - Create minimal todo list with `TodoWrite`
   - NO researcher subagents, NO scout commands

2. **Rapid Implementation**
   - Use `/code` directly on tasks
   - Skip multi-step planning documents
   - Focus on working code over documentation

3. **Quick Validation**
   - Run type-check and compile
   - Manual spot-check over full test suite
   - Skip code-reviewer subagent

4. **Commit** (optional)
   - Ask user if ready to commit via `AskUserQuestion`
   - If yes, use `/commit`

## When to Use

- Simple features with clear requirements
- Bug fixes with known solutions
- Refactoring tasks
- When user says "just do it"

## Trade-offs

| Aspect   | Fast Mode   | Full Mode       |
| -------- | ----------- | --------------- |
| Research | Skipped     | Multiple agents |
| Planning | Minimal     | Full plan docs  |
| Testing  | Quick check | Full test suite |
| Review   | Skipped     | Code-reviewer   |
| Speed    | ~2x faster  | Thorough        |

## 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 provides a fast-implementation workflow for C# tasks, prioritizing immediate coding and rapid delivery over extended research. It creates a minimal plan, executes changes, performs quick validation, and prompts for commit when ready. The mode is optimized for simple features, known bug fixes, and situations where speed is the priority.

How this skill works

On task start it generates a short TodoWrite list and proceeds directly to code changes using the /code flow. It enforces an anti-hallucination step: verify assumptions by searching usages and reading implementations before modifying code. After edits it runs type-check/compile and a spot-check of behavior, then asks whether to commit.

When to use it

Implementing small, well-specified features with clear acceptance criteria
Fixing bugs when the root cause is understood and reproducible
Refactoring a small module or cleanup that has low risk
When the user explicitly requests ‘just do it’ or prioritizes speed
Tight deadlines where a minimal viable change is acceptable

Best practices

Always start with a minimal todo list breaking the task into small steps, including a final review step
Confirm any unclear assumption by inspecting actual code usage and implementations before editing
Limit testing to type checks, compilation, and targeted manual spot-checks for changed code paths
Keep commits focused and small; ask the user before committing to the main branch
Document key intent in short comments where the fast approach makes trade-offs visible

Example use cases

Add a new API endpoint that maps directly to an existing service implementation
Fix an off-by-one or null-check bug discovered in production logs with a clear fix
Refactor naming and small method extraction inside a single class to improve readability
Apply a single performance tweak (e.g., caching) where codepaths are well-understood
Implement a simple feature flag switch and related wiring without broad system changes

FAQ

What if an assumption is wrong after making changes?

Rollback or revert the minimal commit, investigate with more thorough analysis, and reopen the task. The workflow requires verifying assumptions first to reduce this risk.

Will comprehensive tests run in this mode?

No. Fast mode runs quick type-checks, compilation, and spot-checks. Run the full test suite in a follow-up step or switch to a full-mode workflow for exhaustive validation.

Can I use this flow for large or risky changes?

Not recommended. Reserve fast mode for low-risk, well-scoped tasks. For large or complex work, choose a thorough planning and review approach.