Execute a phased implementation plan from a design document. Implements each phase with tests, validates with otto ci, and commits with meaningful messages.
A systematic workflow for implementing multi-phase design documents created with the Rule of Five methodology.
Before using this skill, you must have:
/create-design-doc with the Rule of Five methodology.otto.yml must exist for CI validationFor each phase in the design document:
┌─────────────────────────────────────────────┐
│ 1. Read the phase requirements │
│ 2. Implement code │
│ 3. Write tests for the implementation │
│ 4. Run `otto ci` to validate │
│ 5. Fix issues until CI passes │
│ 6. Commit with meaningful message │
│ 7. Move to next phase │
└─────────────────────────────────────────────┘
Before writing any code:
# Read the design doc
cat docs/<feature>-design.md
Extract for the current phase:
Follow the design doc specifications exactly. If the design doc uses /rust-cli-coder conventions:
Key principle: Implement ONLY what the phase specifies. No gold-plating.
Make sure we have tests that ensure the correctness of our implementation.
Tests must accompany the implementation:
// Unit tests for each new function
#[test]
fn test_new_function_happy_path() { ... }
#[test]
fn test_new_function_error_case() { ... }
For Rust projects, tests go in:
#[cfg(test)] mod tests blocks for unit teststests/ directory for integration testsCoverage target: Every public function should have at least one test.
Validate the implementation:
otto ci
This runs:
cargo check - compilationcargo clippy - lintingcargo fmt --check - formattingcargo test - all testsIf otto ci fails:
otto ciCommon fixes:
cargo fmt for formatting issuesOnce CI passes, commit the phase.
For the final phase commit: include the design document itself in the commit and update its status to "Implemented" before committing. This ensures the design doc and its implementation are shipped together:
# Update design doc status
sed -i 's/^**Status:** Draft/**Status:** Implemented/' docs/design/<feature>.md
# Stage implementation + updated design doc
git add <implementation files> docs/design/<feature>.md
git commit -m "$(cat <<'EOF'
<type>(<scope>): <description>
<body explaining what this phase accomplishes>
Phase N of N: <phase name from design doc>
Design doc: docs/design/<feature>.md
EOF
)"
For non-final phase commits:
git add <implementation files>
git commit -m "$(cat <<'EOF'
<type>(<scope>): <description>
<body explaining what this phase accomplishes>
Phase N of M: <phase name from design doc>
Design doc: docs/design/<feature>.md
EOF
)"
Commit message format:
| Type | Use When |
|---|---|
feat | New functionality |
fix | Bug fix |
refactor | Code restructuring |
test | Test additions |
docs | Documentation changes |
Example:
feat(executor): implement task executor with Anthropic API
Add TaskExecutor that runs agentic loops for tasks, calling the
Anthropic API for completions and executing tool calls.
Phase 2 of 5: Task Executor
Design doc: docs/claude-code-parity-design.md
After committing, IMMEDIATELY proceed to the next phase:
CRITICAL: Do NOT ask the user "Ready for phase N?" or "Should I continue?" CRITICAL: Do NOT pause between phases. Execute ALL phases in sequence until done.
The user invoked this skill expecting all phases to be executed. Stopping to ask breaks the workflow.
Before moving to the next phase, verify:
otto ci passesUser: Execute phase 1 of docs/claude-code-parity-design.md
Agent:
1. Reading phase 1 requirements...
- Implement Glob tool
- Implement Grep tool
- Implement Edit tool
2. Implementing Glob tool in src/agentic/tools/glob.rs...
[writes code]
3. Writing tests for Glob tool...
[writes tests]
4. Running otto ci...
✗ Clippy warning: unused variable
5. Fixing clippy warning...
[edits code]
6. Running otto ci again...
✓ All checks pass
7. Implementing Grep tool...
[continues through all phase 1 items]
8. Final otto ci for phase 1...
✓ All checks pass
9. Committing phase 1...
feat(tools): add Glob, Grep, and Edit tools
Phase 1 of 5: Tool Expansion
Design doc: docs/claude-code-parity-design.md
[IMMEDIATELY continues to phase 2 without pausing]
10. Reading phase 2 requirements...
- Create prompt.rs module
- Write comprehensive system prompt
...
[continues until all phases complete]
If a phase cannot be completed:
| Skill | Integration |
|---|---|
/create-design-doc | Creates the design doc this skill executes |
/rust-cli-coder | Coding conventions for Rust implementations |
/otto | CI validation tool |
/bump | Version bumping after all phases complete |
otto ci validationWhen the final phase is committed and CI is green, execute the finalization sequence without pausing or asking. This is part of the workflow, not a separate step.
Change the design doc's **Status:** from Draft to Implemented, then commit:
git add docs/design/<design-doc>.md
git commit -m "docs: mark <feature> design doc as implemented"
Use the /bump skill to increment the version. Default to patch unless the
design doc describes a breaking change (then minor or major).
Push all commits and tags to the remote:
git push && git push --tags
Build and install the release binary locally:
cargo install --path .
This step assumes a Rust CLI project (which is ~99% of what we build). If the project is not Rust, substitute the equivalent install command.
┌──────────────────────────────────────────────────┐
│ 1. Update design doc status to "Implemented" │
│ 2. Commit the status change │
│ 3. /bump (patch by default) │
│ 4. git push && git push --tags │
│ 5. cargo install --path . │
└──────────────────────────────────────────────────┘
CRITICAL: Do NOT ask the user before running these steps. The user invoked this skill expecting the full pipeline - implement, validate, ship.