implement
A structured development flow that mandates planning before implementation.
Install
mkdir -p .claude/skills/implement-ymahlau && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/14601" && unzip -o skill.zip -d .claude/skills/implement-ymahlau && rm skill.zipInstalls to .claude/skills/implement-ymahlau
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Plan-then-implement workflow — sketches a hypothesis, explores targeted areas, creates a concrete plan, gets user approval, then implements in parallel subagents. Use for non-trivial features or changes.Key capabilities
- →Form a rough hypothesis about codebase changes and approach.
- →Explore the codebase to validate the hypothesis and answer specific questions.
- →Create a concrete implementation plan with file changes and test plans.
- →Implement approved plans using parallel subagents for independent work.
- →Verify implementation by running linters and relevant tests.
How it works
The skill follows a five-phase process: sketching a hypothesis, exploring the codebase, planning the implementation, implementing with subagents, and finally verifying the changes.
Inputs & outputs
When to use implement
- →Building complex features
- →Implementing major code changes
- →Reducing risk in code modifications
About this skill
Plan-Then-Implement Workflow
You are executing a structured implementation workflow for: $ARGUMENTS
Follow these phases strictly in order.
Phase 1: Sketch
Before exploring the codebase, form a rough hypothesis based on what you already know (skills, CLAUDE.md, conversation context, the request itself):
- What areas of the codebase likely need to change?
- What is the rough approach?
- What specific questions need answering before you can make a concrete plan?
Write this sketch down briefly. It does NOT need to be correct — its purpose is to give exploration direction, not to commit to an approach.
Phase 2: Explore
Use the Explore subagent (or multiple in parallel) to validate and refine the sketch. Focus exploration on:
- Answering the specific questions from the sketch
- Verifying that the files and patterns you hypothesized actually exist
- Discovering anything the sketch missed — dependencies, constraints, edge cases
- Checking existing patterns and conventions to follow
- Identifying test patterns used for similar features
Do NOT start writing code yet.
Phase 3: Plan
Enter plan mode. Based on what exploration confirmed or revised, create a concrete implementation plan:
- List every file that needs to be created or modified
- Describe the specific changes for each file
- Identify which changes are independent (can be parallelized) vs sequential
- Note any risks or decisions that need user input
- Include a test plan
Present the plan to the user and wait for approval before proceeding. Do not continue until the user confirms.
Phase 4: Implement
After user approval:
- Create tasks for each piece of work
- Exit plan mode
- Launch implementation subagents in parallel for independent work items (use
isolation: worktreefor parallel file edits to the same files) - Handle sequential work items in order after parallel work completes
- Mark tasks as completed as each finishes
Phase 5: Verify
After all implementation is done:
- Run the linter:
pixi run pre-commit run -a - Run relevant tests:
pixi run python -m pytest tests -m "unit or integration"(adjust markers based on what was changed) - Fix any issues found
- Summarize what was done
When not to use it
- →For trivial features or changes that do not require a structured plan.
- →When a quick, unvalidated implementation is preferred.
- →When user approval for the plan is not feasible or desired.
Limitations
- →The skill requires user approval before proceeding with implementation.
- →The skill is designed for non-trivial features or changes.
- →The skill requires running linters and tests for verification.
How it compares
This workflow structures development into distinct phases with explicit user approval for the plan, reducing risk and technical debt compared to direct implementation.
Compared to similar skills
implement side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| implement (this skill) | 0 | 3mo | No flags | Advanced |
| nx-generate | 1 | 6mo | Review | Beginner |
| agent-sync-coordinator | 1 | 6mo | Review | Advanced |
| aiox-master | 0 | 4mo | No flags | Advanced |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
nx-generate
nrwl
Generate code using nx generators. USE WHEN scaffolding code or transforming existing code - for example creating libraries or applications, or anything else that is boilerplate code or automates repetitive tasks. ALWAYS use this first when generating code with Nx instead of calling MCP tools or running nx generate immediately.
agent-sync-coordinator
ruvnet
Agent skill for sync-coordinator - invoke with $agent-sync-coordinator
aiox-master
ExpeditoJ
AIOX Master Orchestrator & Framework Developer (Orion). Use when you need comprehensive expertise across all domains, framework component creation/modification, workflow orchest...
nx-generate
namGyunKim
Generate code using nx generators. INVOKE IMMEDIATELY when user mentions scaffolding, setup, structure, creating apps/libs, or setting up project structure. Trigger words - scaffold, setup, create a ... app, create a ... lib, project structure, generate, add a new project. ALWAYS use this BEFORE cal
graphflow
Roarpeng
Graph-based code context compression, task planning, and knowledge graph orchestration (10 MCP tools). Invoke before ANY code question, bug fix, debugging, file reading, Chinese/CJK query, refactor, or multi-step edit — ALWAYS call graphflow_context MCP first when GraphFlow is connected.
brainstorming
obra
Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes