skills.rest
open-octo
open-octoOFFICIAL
Explore all skills by this author →
GitHub

implement

Convert technical designs into tested code via dependency-ordered vertical slices.

88|15|Updated May 25, 2026
Search Tags:#tdd#code review#software development#implementation#technical design#state persistence#vertical slices
One-click install
npx skills add https://github.com/open-octo/octo-agent --skill implement-open-octo
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implement
Source: https://github.com/open-octo/octo-agent/tree/main/internal/skills/defaults/implement
Command: npx skills add https://github.com/open-octo/octo-agent --skill implement-open-octo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns a concrete technical design into working, production-ready code without losing architectural intent, test coverage, review quality, or progress across sessions.

Core Features & Use Cases

  • Design Readiness & Decomposition: Validates that the design is implementable and breaks it into dependency-ordered vertical slices with clear acceptance criteria and file ownership.
  • Test-Driven Execution: Implements each behavior through a strict red-green testing cadence, focused commits, external contract verification, and full-suite validation.
  • Review & Recovery: Uses isolated sub-agent reviews, persists slice progress in a state file, handles resumable implementation, and verifies that new functionality is fully wired before a pull request.
  • Use Case: Apply this Skill when a settled API, schema, or feature design needs to be implemented incrementally with traceable tests, review findings, and documented deviations.

Quick Start

Ask the implement skill to implement the provided technical design and proceed slice by slice with tests, reviews, and persistent progress tracking.

Frequently Asked Questions about implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a technical design incrementally with TDD and code review?▼

You can implement a technical design incrementally by decomposing it into dependency-ordered vertical slices, executing each through a strict red-green TDD cadence, and verifying with isolated sub-agent reviews before wiring a pull request.

What is the best way to turn a settled API schema design into production-ready code?▼

Turning a settled API schema design into production-ready code requires breaking the design into vertical slices with clear acceptance criteria, applying test-driven execution, and persisting slice progress in a state file to ensure resumable implementation across sessions.

How does state persistence work for resumable software development across sessions?▼

State persistence for resumable software development works by saving slice progress in a state file, allowing the implementation to recover and resume accurately across sessions without losing test coverage, review findings, or architectural intent.

Do I need a fully specified technical design before starting test-driven implementation?▼

Yes, you need a sufficiently specified technical design before starting test-driven implementation, because the process validates design readiness and requires clear acceptance criteria and file ownership to execute dependency-ordered vertical slices.

How to handle architectural deviations and contract verification during feature implementation?▼

Handling architectural deviations and contract verification during feature implementation involves explicit documentation of changes, running full-suite validation, and verifying external contracts within each isolated vertical slice before final pull request submission.

Why use vertical slices for repository-level feature development instead of horizontal layers?▼

Vertical slices for repository-level feature development ensure that each implemented behavior is fully wired and tested end-to-end through focused commits, maintaining traceable tests and isolated review quality better than horizontal layering.

Related Skills

Explore More Software Engineering Skills→
paulinghampaulingham
1

epic-breakdown

Decompose epics into deployable stories with acceptance criteria and estimates.

Community
Advanced
adryanmoldokkr32-pixeladryanmoldokkr32-pixel

land-and-deploy

Merge pull requests, monitor CI, deploy to production, and verify health with canary checks.

Community
Intermediate
k97k97
4

finishing-a-development-branch

Verify tests before merging or cleaning up git development branches.

Community
Intermediate
matheushenriquefsmatheushenriquefs

mentat-implement

Execute mentat plans slice-by-slice with TDD and gate checks.

Community
Advanced