implementing
Scannednpx machina-cli add skill chris-hendrix/claudehub/implementing --openclawImplementing
Execute implementation from plans, tickets or issues, or descriptions with mandatory review checkpoints.
Multi-session implementation: Large implementations span multiple sessions. The plan file is the source of truth - checkboxes show progress, and any session can resume where the previous one left off.
Philosophy
- Critical Review Before Starting: Read plans skeptically. Assess confidence and raise concerns before executing.
- Phase-by-Phase Execution: Complete one phase fully before moving to the next.
- Mandatory Review Checkpoints: Run success criteria after each phase, get user sign-off.
- Fail Fast: Stop on blockers rather than proceeding speculatively.
Confidence Assessment
Before starting execution, assess confidence in three areas:
| Area | What to evaluate |
|---|---|
| Task | Is the goal clear? Are requirements unambiguous? |
| Existing Code | Is the codebase understood? Are dependencies clear? |
| Plan | Are steps actionable? Are success criteria verifiable? |
Rate each as Low, Medium, or High with visual indicators:
- 🟢 High: Ready to proceed without concerns
- 🟡 Medium: Some uncertainty but manageable - explain what's unclear
- 🔴 Low: Significant gaps - must resolve before proceeding
Present all three ratings to the user. For any rating below High, explain:
- What specific concerns exist
- What information would increase confidence
- Whether to proceed, investigate further, or revise the plan
Low confidence: Recommend further planning or design exploration before proceeding with implementation.
See references/confidence-assessment.md for the detailed template and examples.
Do not begin implementation until user acknowledges the assessment.
Phase Confirmation & Resuming Work
After confidence assessment, present phases and get user confirmation before starting. If resuming work from a previous session, identify where to start based on checkboxes.
See references/implementing-a-plan.md for detailed instructions on phase confirmation and resuming work across sessions.
Execution Model
CRITICAL: Update the plan file continuously as you work. The plan is a living document - check off items, record changes, update status. This enables resuming work across sessions.
Phase Processing
Execute phases sequentially:
- Load phase: Add phase tasks to TodoWrite
- Implement task by task: Complete steps, update both TodoWrite and plan file
- Verify phase: Run checks, get user sign-off
- Move to next phase: Clear TodoWrite, load next phase
See references/implementing-a-plan.md for detailed instructions on:
- What to check off in the plan file and when
- How to update Tracked Changes section
- How to update frontmatter status
- Handling deviations during implementation
Agent Selection
Select agents based on semantic understanding of task requirements:
- Analyze what the task actually requires
- Match to agent capabilities and domain expertise
- Consider task complexity
Stop Conditions
Halt execution immediately when encountering:
- Missing dependencies or prerequisites
- Test failures that indicate broken assumptions
- Unclear or contradictory instructions
- Blocked status from agents
Handling Deviations
When tasks cannot proceed as planned or a better approach is discovered, present options to the user and get approval before deviating. Update the plan file's Tracked Changes section with significant deviations.
See references/implementing-a-plan.md for detailed instructions and examples.
Phase Verification & Completion
After completing each phase, run phase-level checks (automated tests, manual verification) and get user sign-off before proceeding. When all phases complete, write implementation summary to .thoughts/implementations/.
See references/implementing-a-plan.md for detailed verification steps and summary document structure.
Source
git clone https://github.com/chris-hendrix/claudehub/blob/main/plugins/rpi/skills/implementing/SKILL.mdView on GitHub Overview
Implementing turns a plan, ticket, or description into a working build using phased execution and mandatory reviews. It treats the plan as the source of truth, supports multi-session work, and requires user sign-off after each phase.
How This Skill Works
Read and critique the plan before starting. Break the work into sequential phases, load each phase's tasks into TodoWrite, execute task-by-task, then verify and obtain sign-off before moving on. The plan is updated continuously to enable resumption across sessions.
When to Use It
- Starting a new ticket or feature by following an explicit plan.
- Building from a natural-language description into concrete tasks.
- Working on large implementations across multiple sessions.
- When you need mandatory review checkpoints after each phase.
- When you must stop on blockers or uncertainties and re-plan.
Quick Start
- Step 1: Review the plan and confidence assessment.
- Step 2: Load the first phase into TodoWrite and begin execution.
- Step 3: After completing each phase, run checks and obtain sign-off before proceeding.
Best Practices
- Perform the Critical Review Before Starting.
- Execute Phase-by-Phase, finishing one phase before the next.
- Run success criteria after each phase and get user sign-off.
- Update the plan file continuously, including Tracked Changes.
- Use Stop Conditions to halt on blockers or unclear instructions.
Example Use Cases
- Implementing a feature from a design document with phased milestones.
- Completing a Jira ticket by executing one phase at a time.
- Migrating a module per a plan with checkpoints.
- Adding a new API integration guided by a description and success criteria.
- Refactoring with verification steps after each phase.
