This skill should be used when the user asks to "implement the feature", "write the code", "build it", or when the harness:feature orchestrator invokes the Implement phase.
Implements features by creating a plan, getting approval, and executing code changes.
/plugin marketplace add astrosteveo/marketplace/plugin install harness@astrosteveo-marketplaceThis skill is limited to using the following tools:
This phase implements the feature according to the approved design.
Phase Requirements (in order):
If invoked via orchestrator: Receives $ARGUMENTS:
feature_slug: Feature identifierfeature_description: What to buildartifacts_path: Path to .artifacts/{slug}/tdd_mode: Whether to use test-driven developmentIf invoked directly: Check for existing artifacts. Read design.md if available. If starting fresh, ask for what to implement and how.
Read existing artifacts:
{artifacts_path}/progress.md - Current state{artifacts_path}/requirements.md - What must be built{artifacts_path}/design.md - How to build itSearch engram for implementation patterns:
mcp__plugin_engram-mcp_engram__memory_search
query: "{feature_description} implementation code"
n_results: 5
mcp__plugin_engram-mcp_engram__memory_insights
query: "implementation {feature_type}"
insight_type: "lesson"
n_results: 5
Past lessons (bugs, gotchas) are especially valuable here.
Edit progress.md:
CRITICAL: Before writing ANY code, create .artifacts/{slug}/plan.md using the Write tool.
This file MUST exist before proceeding. Based on design.md, write this file:
# {Feature Name} - Implementation Plan
## Approach
{Name of chosen approach from design phase}
## Files to Modify
| File | Changes | Order |
|------|---------|-------|
| `path/to/file.ts` | {what changes} | 1 |
| `path/to/other.ts` | {what changes} | 2 |
## Files to Create
| File | Purpose | Order |
|------|---------|-------|
| `path/to/new.ts` | {purpose} | 3 |
## Implementation Steps
### Step 1: {Component/File}
- [ ] {Specific task}
- [ ] {Specific task}
### Step 2: {Component/File}
- [ ] {Specific task}
- [ ] {Specific task}
## Testing Strategy
{How to verify each component works}
## Commit Strategy
{Logical commit points}
After creating plan.md, present it to the user.
PAUSE POINT - DO NOT SKIP
Do NOT write any code until the user confirms.
If NOT in TDD mode, implement following the plan:
Work through steps in order
Commit frequently
feat({slug}): add {component}
feat({slug}): implement {behavior}
Update plan.md
Handle blockers
If TDD mode enabled:
Create test plan first
Add to plan.md:
## Test Cases (TDD Order)
1. {Behavior}: {test description}
2. {Behavior}: {test description}
For each test case, follow Red-Green-Refactor:
RED - Write failing test
# Run test, verify it fails
Commit: test({slug}): add failing test for {behavior}
GREEN - Write minimum code to pass
# Run test, verify it passes
Commit: feat({slug}): implement {behavior}
REFACTOR - Clean up if needed
Commit: refactor({slug}): {description}
Repeat for all test cases
If bugs encountered or gotchas discovered during implementation:
mcp__plugin_engram-mcp_engram__memory_lesson
content: "When implementing {feature_type}: {lesson}. Root cause: {cause}."
category: "bug_fix" or "gotcha"
root_cause: "{cause}"
If useful patterns emerged:
mcp__plugin_engram-mcp_engram__memory_lesson
content: "Pattern for {feature_type}: {pattern}. Works well because {reason}."
category: "pattern"
Add to progress.md:
## Implementation
### Files Changed
| File | Changes |
|------|---------|
| `path` | {summary} |
### Files Created
| File | Purpose |
|------|---------|
| `path` | {purpose} |
### Commits
- `{hash}` - {message}
- `{hash}` - {message}
### Deviations from Plan
- {Any changes from original plan and why}
### Issues Encountered
- {Issue}: {how resolved}
Summarize for Review phase:
Stop hook validates:
progress.md updated with "Phase: Implement"plan.md exists with implementation steps| When | Tool | Purpose |
|---|---|---|
| Start | memory_search | Find implementation patterns |
| Start | memory_insights | Get past lessons/bugs |
| During | memory_lesson | Record bugs discovered |
| End | memory_lesson | Record patterns that worked |
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.