Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

implement

/implement

Prawdopodobnie prowadzi przez implementację zadania lub planu: rozpoczęcie pracy nad zadaniem i wykonanie zaplanowanych kroków.

Repozytorium
engy ↗
Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prawdopodobnie prowadzi przez implementację zadania lub planu: rozpoczęcie pracy nad zadaniem i wykonanie zaplanowanych kroków.

Wyzwalacze z opisu

implementimplement a taskimplement a planexecute a planwork on taskstart implementation
Oryginalny opis (EN)

This skill should be used when the user asks to 'implement', 'implement a task', 'implement a plan', 'execute a plan', 'work on task', or 'start implementation'.

Jak działa

  1. MCP Tools
  2. Step 1: Gather Context
  3. Step 2: Discover Validation Gates
  4. Step 3: Create Session Tasks
  5. Step 4: Implement via TDD (Red-Green-Refactor)
  6. Step 5: Final Validation
  7. Capture Learnings as Memories
  8. Engy Task Status Flow
  9. Step 6: Final Output
  10. Key Principles
Sekcje z nagłówków SKILL.md, w oryginale · 126 linii, 1 230 słów
Podgląd SKILL.md
---
name: implement
description: "This skill should be used when the user asks to 'implement', 'implement a task', 'implement a plan', 'execute a plan', 'work on task', or 'start implementation'."
---

# Task Implementation

Implements a single task or plan document end-to-end: context gathering, TDD implementation, code review, and validation. For milestone-level orchestration across multiple task groups, use `/engy:implement-milestone`.

## MCP Tools

- `getTask(id)` — task details including title, description, status (null fields are omitted)
- `updateTask(id, status)` — mark tasks `in_progress` / `review` / `done`
- `getProjectDetails(projectId)` — project paths

## Step 1: Gather Context

**EARS-BDD mode:** check whether EARS-BDD is enabled for this workspace — the agent's appended system prompt or `getWorkspaceDetails` will indicate it (e.g. an `earsBdd: true` flag or similar). When enabled, follow `references/ears-bdd.md`, which adds FR-establishment before Step 4, FR-tagging to the Red step, and coverage verification to Step 5. When disabled, run the steps below unchanged.

### A. From an Engy Task

1. `getTask(id)` — read the task's title, description, and status.
2. **Check for existing work** — If task status is `in_progress`:
   - Run `git status` and `git diff` to identify uncommitted changes related to this task.
   - Review changed files to understand what's already done vs. what remains.
   - Adjust implementation scope to only cover remaining work.
3. If the task description references a plan document path, read that plan — it is the primary requirements source. Otherwise the task description itself is the requirements source.
4. `updateTask(id, status: "in_progress")`.

### B. From a Plan Document

1. Read the plan document in full (path or inline content from user).
2. Extract **phases** (requirements + deliverables), **test scenarios** (acceptance criteria), and **dependencies** between phases.
3. The plan document is the primary requirements source.

## Step 2: Discover Validation Gates

Read the project's **CLAUDE.md** for explicit validation and testing instructions.

## Step 3: Create Session Tasks

CRITICAL: Before writing any code, create internal session tasks (`TaskCreate`) for **every step** of the implementation. This ensures progress is tracked and nothing is missed.

**Copy the plan's phases and deliverables in verbatim before adding your own tasks.** The failure mode is reading a plan, then writing a fresh task list that quietly drops its named steps. A step you decide not to do stays in the list as `skip: <reason>` — dropping it silently is not allowed, because the reason is what the user reviews.

Create one task per small, independent unit of work. Keep tasks focused — each should be completable on its own.

1. **Implementation tasks** — one per logical unit (e.g., "Add X migration", "Implement Y service", "Write tests for Z").
2. **Final validation task** — always the last task. See Step 5.

Chain dependencies with `TaskUpdate` (`addBlockedBy`) so tasks execute in order.

**Example:**
- Task #1: "Add user preferences table migration"
- Task #2: "Implement preferences service" (blocked by #1)
- Task #3: "Add API endpoint for preferences" (blocked by #2)
- Task #4: "Run /engy:review, then the validation gate from Step 2" (blocked by #3) — CRITICAL, always required

## Step 4: Implement via TDD (Red-Green-Refactor)

**EARS-BDD mode:** before the first test, establish the target FR ids — run the "Before Step 4 — establish target FR ids" hand-off in `references/ears-bdd.md` (locate pre-planned ids in the plan/spec, or dispatch `engy:feature-author`), then tag each Red test with its FR id and verify coverage in Step 5. Skip this when EARS-BDD is disabled.

For each implementation task, follow the TDD cycle strictly:

1. Mark the session task `in_progress`.
2. **Red** — Write a failing test first. Test scenarios come from the requirements source (task description or plan) — never invented without basis. **Test strategy cascade:** requirements source > project config > codebase conventions.
3. **Green** — Write the minimum code to make the test pass.
4. **Refactor** — Clean up the implementation while keeping tests green. Remove duplication, improve naming, simplify.
5. Repeat the red-green-refactor cycle until the task's requirements are fully covered.
6. Run the task's area tests to confirm everything passes. Mark session task completed.

**When the task is a bug fix**, the Red test must fail for the *confirmed* reason, not just fail. Trace the symptom to its mechanism before designing the fix, then ship the smallest change that mechanism justifies. A guard that silences a symptom you never traced is a hypothesis, not a fix — and code motivated by a hypothesis you later disproved gets reverted, not left in as insurance.

## Step 5: Final Validation

CRITICAL: This step is **always required** as the last session task. It follows whatever the project's CLAUDE.md specifies for quality gates.

Grade every claim in this step on the evidence ladder, and end each check with one of **VERIFIED** / **NOT VERIFIED** / **INCONCLUSIVE**. Inconclusive is not a pass. Report the rung you reached, not just the outcome — "it builds" is rung 1 for anything the test suite does not cover.

After all implementation tasks are done:

1. Run `/engy:review`.
2. Run the **full validation command** discovered in Step 2. Read complete output, verify explicitly — never assume success.
3. Triage feedback by severity (Critical → High → Medium). Address all Critical and High items, re-run validation.
4. **Circuit breaker:** after 3 failed validation/review cycles, stop and report to user with diagnostics.
5. Run any manual checks specified in project config. UI work reaches rung 5 (driven in a real browser) or it is not done.
6. On success: commit the changes, mark all session tasks completed.

## Capture Learnings as Memories

When you discover non-obvious patterns, gotchas, or architectural decisions during implementation:

- **In-flight capture**: call `updateTask(id, { memories: [{ content, type? }] })` alongside any status update. Do this immediately when you learn something surprising — don't wait until the end.
- **Completion output**: include a `memories` array in your structured completion JSON for any learnings not already captured mid-task.

What makes a good memory: short, concrete, surprising. Save what would force a future agent to re-learn through trial and error. Do not save things discoverable by reading the code (file structures, function signatures) — save the reasoning, gotchas, and non-obvious decisions.

**Examples of good memories:**
- "the codegen step must run after any schema change, or the migration silently omits the new column"
- "the cache invalidates on a TTL, not on write — a read straight after a write can still return stale data"
- "the request/response map entry must be deleted in the response handler, or every timed-out request leaks"

## Engy Task Status Flow

When working from an Engy task, update its status via `updateTask(id, status)`:

1. **`in_progress`** — set when starting work (Step 1).
2. **`review`** — set if the task needs human input before it can be marked done.
3. **`done`** — set once changes are committed.

## Step 6: Final Output

After all work is complete, present a summary to the user:

1. **Changes made** — brief summary of what was implemented.
2. **Validation gates** — each gate with its verdict, evidence rung, and artifact.
3. **Follow-ups** — remaining issues, deferred feedback, every `skip: <reason>` from Step 3, and anything left INCONCLUSIVE.

## Key Principles

- **Context before code.** Always gather task details before writing any code.
- **Evidence before claims.** Grade every claim on the evidence ladder and say where it stopped.
- **Task tracking.** Create session tasks for every step — nothing happens untracked, and nothing is dropped without a `skip: <reason>`.

## Additional resources

- For the evidence ladder and the three verdicts, see [references/evidence-ladder.md](references/evidence-ladder.md)
- For EARS-BDD mode, see [references/ears-bdd.md](references/ears-bdd.md)

Pliki w paczce (3)
  • SKILL.md 8 KB
  • references/ears-bdd.md 16 KB
  • references/evidence-ladder.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · zanderadam/engy100MIT
ericrisco/rsc-harness100MIT
yonatangross/orchestkit100MIT
sentimony/agentic-workflow100MIT
moberghr/mtk-agent-toolkit100MIT
michielvandermeer/skills100MIT
rossumai/claude-marketplace100MIT
userKael/rastro100MIT
yonatangross/orchestkit100MIT

Migawka bazy z 13.11.2026 · wersja paczki 55d24efe0bd9 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100implement-feature
    Prowadzi pełny workflow implementacji funkcji: przegląd planu, pisanie testów, kod, weryfikacja i dostarczenie.
  • 100implement-feature
    Prowadzi pełny workflow implementacji funkcji po zatwierdzeniu planu lub historyjki, a końcowe przekazanie deleguje do completing-a-task.
  • 95unikit-implement
    Wykonuje zadania z gotowego planu funkcji w .unikit/code/plans/: czyta manifest PLAN.md, realizuje niedokończone zadania po kolei, oznacza postęp i wznawia pracę między sesjami.
  • 84execute-plan
    Wykonuje plany wdrożenia krok po kroku, także jako stos pull requestów z jednym PR na krok.
  • 100implement-phase
    Wykonuje jedną fazę planu wdrożenia ze wszystkimi bramkami jakości: implementacją, weryfikacją, przeglądem kodu, zgodnością z ADR i synchronizacją planu.
  • 100implement-plan
    Realizuje zatwierdzony plan wdrożenia fazę po fazie, uruchamiany frazami w rodzaju „zrób to” albo „zaimplementuj plan” oraz ścieżką do pliku planu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.