playbooks

home / skills / yonatangross / orchestkit / implement

implement skill

/plugins/ork/skills/implement

This skill enables rapid feature implementation with parallel subagents and scope-driven reflection to accelerate development from conception to tests.

npx playbooks add skill yonatangross/orchestkit --skill implement

Review the files below or copy the command above to add this skill to your agents.

Files (19)
SKILL.md
7.6 KB
---
name: implement
license: MIT
compatibility: "Claude Code 2.1.34+. Requires memory MCP server, context7 MCP server, network access."
description: "Full-power feature implementation with parallel subagents. Use when implementing, building, or creating features."
argument-hint: "[feature-description]"
context: fork
version: 2.3.0
author: OrchestKit
tags: [implementation, feature, full-stack, parallel-agents, reflection, worktree]
user-invocable: true
allowed-tools: [AskUserQuestion, Bash, Read, Write, Edit, Grep, Glob, Task, TaskCreate, TaskUpdate, mcp__context7__query_docs, mcp__memory__search_nodes]
skills: [api-design, react-server-components-framework, type-safety-validation, testing-patterns, explore, verify, memory, worktree-coordination, scope-appropriate-architecture]
complexity: medium
metadata:
  category: workflow-automation
  mcp-server: memory, context7
---

# Implement Feature

Parallel subagent execution for feature implementation with scope control and reflection.

## Quick Start

```bash
/implement user authentication
/implement real-time notifications
/implement dashboard analytics
```

---

## Step 0: Project Context Discovery

**BEFORE any work**, detect the project tier. This becomes the complexity ceiling for all patterns.

### Auto-Detection

Scan codebase for signals: README keywords (take-home, interview), `.github/workflows/`, Dockerfile, terraform/, k8s/, CONTRIBUTING.md.

### Tier Classification

| Signal | Tier | Architecture Ceiling |
|--------|------|---------------------|
| README says "take-home", time limit | **1. Interview** ([details](references/interview-mode.md)) | Flat files, 8-15 files |
| < 10 files, no CI | **2. Hackathon** | Single file if possible |
| `.github/workflows/`, managed DB | **3. MVP** | MVC monolith |
| Module boundaries, Redis, queues | **4. Growth** | Modular monolith, DI |
| K8s/Terraform, monorepo | **5. Enterprise** | Hexagonal/DDD |
| CONTRIBUTING.md, LICENSE | **6. Open Source** | Minimal API, exhaustive tests |

If confidence is low, use `AskUserQuestion` to ask the user. Pass detected tier to ALL downstream agents — see `scope-appropriate-architecture`.

### Tier → Workflow Mapping

| Tier | Phases | Max Agents |
|------|--------|-----------|
| 1. Interview | 1, 5 only | 2 |
| 2. Hackathon | 5 only | 1 |
| 3. MVP | 1-6, 9 | 3-4 |
| 4-5. Growth/Enterprise | All 10 | 5-8 |
| 6. Open Source | 1-7, 9-10 | 3-4 |

Use `AskUserQuestion` to verify scope (full-stack / backend-only / frontend-only / prototype) and constraints.

### Orchestration Mode

- Agent Teams (mesh) when `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` and complexity >= 2.5
- Task tool (star) otherwise; `ORCHESTKIT_FORCE_TASK_TOOL=1` to override
- See [Orchestration Modes](references/orchestration-modes.md)

---

## Task Management (MANDATORY)

Create tasks with `TaskCreate` BEFORE doing any work. Each phase gets a subtask. Update status with `TaskUpdate` as you progress.

---

## Workflow (10 Phases)

| Phase | Activities | Agents |
|-------|------------|--------|
| **1. Discovery** | Research best practices, Context7 docs, break into tasks | — |
| **2. Micro-Planning** | Detailed plan per task ([guide](references/micro-planning-guide.md)) | — |
| **3. Worktree** | Isolate in git worktree for 5+ file features ([workflow](references/worktree-workflow.md)) | — |
| **4. Architecture** | 5 parallel background agents | workflow-architect, backend-system-architect, frontend-ui-developer, llm-integrator, ux-researcher |
| **5. Implementation + Tests** | Parallel agents, single-pass artifacts with mandatory tests | backend-system-architect, frontend-ui-developer, llm-integrator, test-generator, rapid-ui-designer |
| **6. Integration Verification** | Code review + real-service integration tests | backend, frontend, code-quality-reviewer, security-auditor |
| **7. Scope Creep** | Compare planned vs actual ([detection](references/scope-creep-detection.md)) | workflow-architect |
| **8. E2E Verification** | Browser + API E2E testing ([guide](references/e2e-verification.md)) | — |
| **9. Documentation** | Save decisions to memory graph | — |
| **10. Reflection** | Lessons learned, estimation accuracy | workflow-architect |

See [Agent Phases](references/agent-phases.md) for detailed agent prompts and spawn templates.

For Agent Teams mode, see [Agent Teams Phases](references/agent-teams-phases.md).

### Issue Tracking

If working on a GitHub issue, run the Start Work ceremony from `issue-progress-tracking` and post progress comments after major phases.

### Feedback Loop

Maintain checkpoints after each task. See [Feedback Loop](references/feedback-loop.md) for triggers and actions.

---

## Test Requirements Matrix

Phase 5 test-generator MUST produce tests matching the change type:

| Change Type | Required Tests | `testing-patterns` Rules |
|-------------|---------------|--------------------------|
| API endpoint | Unit + Integration + Contract | `integration-api`, `verification-contract`, `mocking-msw` |
| DB schema/migration | Migration + Integration | `integration-database`, `data-seeding-cleanup` |
| UI component | Unit + Snapshot + A11y | `unit-aaa-pattern`, `integration-component`, `a11y-jest-axe`, `e2e-playwright` |
| Business logic | Unit + Property-based | `unit-aaa-pattern`, `pytest-markers`, `verification-property` |
| LLM/AI feature | Unit + Eval | `llm-deepeval`, `llm-mocking`, `llm-structured` |
| Full-stack feature | All of the above | All matching rules |

### Real-Service Detection (Phase 6)

Before running integration tests, detect infrastructure:

```python
# Auto-detect real service testing capability (PARALLEL)
Glob(pattern="**/docker-compose*.yml")
Glob(pattern="**/testcontainers*")
Grep(pattern="testcontainers|docker-compose", glob="requirements*.txt")
Grep(pattern="testcontainers|docker-compose", glob="package.json")
```

If detected: run integration tests against real services, not just mocks. Reference `testing-patterns` rules: `integration-database`, `integration-api`, `data-seeding-cleanup`.

### Phase 9 Gate

**Do NOT proceed to Phase 9 (Documentation) if test-generator produced 0 tests.** Return to Phase 5 and generate tests for the implemented code.

---

## Key Principles

- **Tests are NOT optional** — each task includes its tests, matched to change type (see matrix above)
- **Parallel when independent** — use `run_in_background: true`, launch all agents in ONE message
- **128K output** — generate complete artifacts in a single pass, don't split unnecessarily
- **Micro-plan before implementing** — scope boundaries, file list, acceptance criteria
- **Detect scope creep** (phase 7) — score 0-10, split PR if significant
- **Real services when available** — if docker-compose/testcontainers exist, use them in Phase 6
- **Reflect and capture lessons** (phase 10) — persist to memory graph

---

## Related Skills

- explore: Explore codebase before implementing
- verify: Verify implementations work correctly
- worktree-coordination: Git worktree management patterns
- issue-progress-tracking: Auto-updates GitHub issues with commit progress

## References

- [Agent Phases](references/agent-phases.md)
- [Agent Teams Phases](references/agent-teams-phases.md)
- [Interview Mode](references/interview-mode.md)
- [Orchestration Modes](references/orchestration-modes.md)
- [Feedback Loop](references/feedback-loop.md)
- [CC Enhancements](references/cc-enhancements.md)
- [Agent Teams Full-Stack Pipeline](references/agent-teams-full-stack.md)
- [Team Worktree Setup](references/team-worktree-setup.md)
- [Micro-Planning Guide](references/micro-planning-guide.md)
- [Scope Creep Detection](references/scope-creep-detection.md)
- [Worktree Workflow](references/worktree-workflow.md)
- [E2E Verification](references/e2e-verification.md)

Overview

This skill orchestrates full-feature implementation using parallel subagents, scope control, and iterative reflection. It detects project context, maps an appropriate workflow, and runs phased agents to deliver code, tests, integration checks, and documentation. Use it to implement features reliably across backend, frontend, and LLM surfaces with enforced testing and scope management.

How this skill works

The skill auto-detects the project tier by scanning repository signals and asks clarifying questions when necessary to confirm scope. It creates structured tasks, selects an orchestration mode (agent teams or task tool), and spawns parallel subagents across a 10-phase workflow—from discovery and micro-planning through implementation, integration verification, and reflection. Mandatory test generation and integration checks gate documentation and completion.

When to use it

  • Implementing a new feature end-to-end (backend, frontend, or full-stack).
  • Adding LLM-enabled capabilities where structured tests and evaluations are required.
  • Working on medium-to-large changes that benefit from parallel development (multiple files or modules).
  • Needing enforced test coverage and integration verification before merge.
  • Coordinating multi-agent work or converting a plan into tracked tasks and artifacts.

Best practices

  • Run project context discovery first to set a realistic architectural ceiling and allowable patterns.
  • Create TaskCreate entries for each phase and update them with TaskUpdate as work progresses.
  • Micro-plan before writing code: file list, acceptance criteria, and task breakdown.
  • Generate matching tests in Phase 5 according to the change type; do not proceed to documentation if tests are missing.
  • Use real-service integration when docker-compose/testcontainers are detected for more reliable verification.
  • Use parallel agents only for independent work and maintain checkpoints after each task for feedback.

Example use cases

  • Implement user authentication with backend endpoints, DB migration, tests, and frontend flows.
  • Add a real-time notifications feature with websocket endpoints, UI components, and end-to-end tests.
  • Build an LLM-powered autocomplete with unit+eval tests and integration into existing APIs.
  • Ship dashboard analytics involving data migrations, API endpoints, UI components, and verification.
  • Triage and implement a GitHub issue with Start Work ceremony and progress comments after major phases.

FAQ

How does the skill decide orchestration mode?

It uses detected complexity and environment flags: agent teams when CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 and complexity >= 2.5; otherwise the task tool. An override env var can force the task tool.

What happens if tests are not produced in Phase 5?

Phase 9 (documentation) is blocked. The workflow returns to Phase 5 to generate the required tests matching the change type before continuing.