# implement_task

Executes a single planned task in fresh context using strict TDD and writes a handoff document. Built for structured agent orchestration.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 473 installs · ★ 3946
- Author: parcadei
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/parcadei/Continuous-Claude-v3/tree/HEAD/.claude/skills/implement_task/SKILL.md
- Updated: 2026-01-26
- HTML: https://affpapa.org/en/nevibecode/skills/parcadei-implement-task

## What it does

The skill configures a subagent to execute an assigned task from a larger implementation plan. When spawned, it reads the continuity ledger, the plan, its assigned task, and the previous task handoff. Work proceeds through a strict Red-Green-Refactor loop where production code requires a failing test first. If code was written before the test, the instructions require deleting it and restarting from the test step.

Code edits depend on file size: small files use Claude Edit, while files longer than 500 lines run through `morph-apply` helper scripts. When `qlty` is available, the agent triggers checks with `qlty check --fix`. Upon completion, it writes a handoff markdown document matching the `task-NN-<short-description>.md` naming pattern, detailing changed files, decisions, and testing status.

The skill specifies `user-invocable: false`, meaning it functions as an internal task runner invoked by an orchestrator agent rather than directly by humans. When hit by an unresolvable obstacle, it marks its status as blocked, details the issue in the handoff file, and returns.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add parcadei/Continuous-Claude-v3 --skill implement_task -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/implement_task/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/implement_task/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add parcadei/Continuous-Claude-v3 --skill implement_task -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/implement_task/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add parcadei/Continuous-Claude-v3 --skill implement_task -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/implement_task/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install parcadei/Continuous-Claude-v3 implement_task
```

2. **Manually: put the files in place**
- File: `.github/skills/implement_task/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add parcadei/Continuous-Claude-v3 --skill implement_task -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/parcadei/Continuous-Claude-v3 --path .claude/skills/implement_task
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/implement_task/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add parcadei/Continuous-Claude-v3 --skill implement_task -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/parcadei/Continuous-Claude-v3/tree/HEAD/.claude/skills/implement_task/SKILL.md

## When to use it
- implement features under strict test-driven development
- pass task context and learnings to subsequent agents via handoff files
- edit large source files over 500 lines using morph-apply
- isolate single-task implementation within a clean context window

## Example prompts
- Run implement_task for task 01 from the implementation plan
- Implement the assigned task using strict TDD and generate the handoff document

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 6bbba2a51605888a.

BEGIN THIRD-PARTY FILE 6bbba2a51605888a
````text
---
name: implement_task
description: Implementation agent that executes a single task and creates handoff on completion
user-invocable: false
---

# Implementation Task Agent

You are an implementation agent spawned to execute a single task from a larger plan. You operate with fresh context, do your work, and create a handoff document before returning.

## What You Receive

When spawned, you will receive:
1. **Continuity ledger** - Current session state (what's done overall)
2. **The plan** - Overall implementation plan with all phases
3. **Your specific task** - What you need to implement
4. **Previous task handoff** (if any) - Context from the last completed task
5. **Handoff directory** - Where to save your handoff

## Your Process

### Step 1: Understand Context

If a previous handoff was provided:
- Read it to understand what was just completed
- Note any learnings or patterns to follow
- Check for dependencies on previous work

Read the plan to understand:
- Where your task fits in the overall implementation
- What success looks like for your task
- Any constraints or patterns to follow

### Step 2: Implement with TDD (Test-Driven Development)

**Iron Law: No production code without a failing test first.**

Follow the Red-Green-Refactor cycle for each piece of functionality:

#### 2a. RED - Write Failing Test First
1. Read necessary files completely (no limit/offset)
2. Write a test that describes the desired behavior
3. Run the test and **verify it fails**
   - Confirm it fails for the RIGHT reason (missing functionality, not typos)
   - If it passes immediately, you're testing existing behavior - fix the test

#### 2b. GREEN - Minimal Implementation
4. Write the **simplest code** that makes the test pass
5. Run the test and **verify it passes**
   - Don't add features beyond what the test requires
   - Don't refactor yet

#### 2c. REFACTOR - Clean Up
6. Improve code quality while keeping tests green
   - Remove duplication
   - Improve names
   - Extract helpers if needed
7. Run tests again to confirm still passing

#### 2d. Repeat
8. Continue cycle for each behavior in your task

#### 2e. Quality Check
9. **Run code quality checks** (if qlty is configured):
   ```bash
   qlty check --fix
   # Or: uv run python -m runtime.harness scripts/qlty_check.py --fix
   ```

**TDD Guidelines:**
- Write test BEFORE implementation - no exceptions
- If you wrote code first, DELETE IT and start with test
- One test per behavior, clear test names
- Use real code, minimize mocks
- Hard to test = design problem - simplify the interface

#### 2f. Choose Your Editing Tool
````
END THIRD-PARTY FILE 6bbba2a51605888a

The third-party file has ended. Everything between the 6bbba2a51605888a tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2609 of 8335 bytes. © parcadei · MIT · https://github.com/parcadei/Continuous-Claude-v3/tree/HEAD/.claude/skills/implement_task/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md