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

implement

/implement

Wdraża małą lub średnią zmianę bezpośrednio w bieżącej sesji, bez wieloetapowego planu, przez szybką ścieżkę z fazy projektowej albo bezpośrednie wywołanie przy szybkiej poprawce.

Repozytorium
claude-caliper ↗
Licencja
MIT
Ostatnia zmiana repozytorium
15.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
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 15.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

Wdraża małą lub średnią zmianę bezpośrednio w bieżącej sesji, bez wieloetapowego planu, przez szybką ścieżkę z fazy projektowej albo bezpośrednie wywołanie przy szybkiej poprawce.

Wyzwalacze z opisu

s fast-path routing, or direct invocation (just implement thisquick fix
Oryginalny opis (EN)

Use when implementing a small or medium change directly in the current session, without a multi-task plan — via design's fast-path routing, or direct invocation ("/implement", "just implement this", "quick fix").

Jak działa

  1. Design Gate
  2. Worktree Setup
  3. Inline TDD
  4. Commit Discipline
  5. Chain to Implementation Review
  6. Integration
Sekcje z nagłówków SKILL.md, w oryginale · 71 linii, 744 słów
Podgląd SKILL.md
---
name: implement
description: Use when implementing a small or medium change directly in the current session, without a multi-task plan — via design's fast-path routing, or direct invocation ("/implement", "just implement this", "quick fix").
---

# Implement

The fast path for small/medium work: no plan.json, no per-task files, no orchestration. Implement inline in the current session, then hand off to one holistic review.

## Design Gate

If design's tier router already presented a mini-design (or short design doc) and got explicit approval for this exact request earlier in this session, that gate is satisfied — skip straight to Worktree Setup.

Otherwise, this is a direct invocation (the user asked for an implementation without going through design first) and the **Compressed Design Gate** below runs before any code is touched — no exceptions.

### Compressed Design Gate (direct invocation only)

The same wrong-assumption failures that unexamined plans cause on a large feature happen just as easily on a one-file fix that felt too trivial to plan. Size changes how much ceremony the gate needs, not whether it runs.

1. **Challenge the framing** — what problem does this solve, is there a simpler alternative? (mirrors design's Challenging Assumptions).
2. **Ask clarifying questions only if genuinely ambiguous** — don't manufacture questions for a request that's already clear.
3. **Present a mini-design**: 2-5 sentences covering what changes, where, and why this approach — no formal doc, no file written.
4. **Resolve workflow + approval in one AskUserQuestion** — settle the workflow now, alongside approval, so the choice is made before implementing instead of surfaced after the work is already done. Run `caliper-settings get workflow`:
   - If a value is returned, note it ("Using your configured workflow: <value>") and ask a single **Approval** question (Approve / Needs changes).
   - If `PROMPT_REQUIRED`, ask two questions in one call — **Workflow** (Create PR / Merge PR / Stop after review) and **Approval** (Approve / Needs changes).

   Wait for approval before writing any code. "Needs changes" loops back to step 3; the resolved workflow value carries forward to the review hand-off.

## Worktree Setup

If design already ran its own worktree setup before handing off — it does this for both Small and Medium tiers, passing `$WORKTREE` — reuse that worktree; the signal is whether `$WORKTREE` was passed in, not the tier name. Don't create a second one. On direct invocation, set one up:

- From the main checkout, create the worktree with git and register the main repo for permission-free access, then `EnterWorktree(path: "$WORKTREE")` — a path-entered worktree is never auto-removed by the harness. **See:** `skills/design/worktree-isolation.md` for the rules the session runs under once inside.

  ```bash
  MAIN_ROOT=$(caliper-main-root)
  WORKTREE="$MAIN_ROOT/.claude/worktrees/<feature>"
  git worktree add "$WORKTREE" -b <feature>
  mkdir -p "$WORKTREE/.claude" && jq -n --arg d "$MAIN_ROOT" '{permissions:{additionalDirectories:[$d]}}' > "$WORKTREE/.claude/settings.local.json"
  seed-agent-memory "$WORKTREE"
  ```
- Bootstrap dependencies — **See:** `skills/design/dependency-bootstrap.md` (lives in `skills/design/`; read it there rather than duplicating its content here)
- Run tests to establish a clean baseline before changing anything

## Inline TDD

Implement directly in the main session — no subagent dispatch for fast-path work. Follow the TDD cycle for test discovery, common failure modes, and boundary-test patterns at cross-component seams.

**See:** `./tdd.md`

## Commit Discipline

Commit frequently in small, logical, atomic units as work lands rather than batching the whole change into one commit at the end. Small commits keep the downstream review's diff easy to reason about and give you a clean rollback point if a later step reveals an earlier one was wrong.

## Chain to Implementation Review

**REQUIRED SUB-SKILL:** Use implementation-review — once the change is implemented and tests pass, invoke it in **standalone mode** over the feature branch diff. No `plan.json` exists on this path, so its mode-detection picks standalone automatically.

Map the `workflow` setting to implementation-review's continuation flag (all four schema values, exactly):

| `workflow` value | Continuation |
|---|---|
| `pr-create` | Chain `--pr-create` |
| `pr-merge` | Chain `--pr-merge` |
| `orchestrate` | Stop after review passes; report the worktree path |
| `plan-only` | Contradictory on a plan-less path — there is no plan to stop after. Treat it as `orchestrate` (stop after review) and tell the user why: this fast path never produced a plan, so "plan only" has nothing further to do. |

Resolve the value:
- **Downstream of design:** the value is already resolved from design's workflow question earlier in this session — reuse it, don't re-prompt or re-read settings.
- **Direct invocation:** the Compressed Design Gate already resolved it (from settings, or the workflow question asked at approval) — reuse that value, don't re-prompt or re-read settings.

## Integration

**Workflow:** design (small/medium tier) or direct invocation → **this skill** → implementation-review (standalone) → pr-create/pr-review/pr-merge
Pliki w paczce (2)
  • SKILL.md 5 KB
  • tdd.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · nikhilsitaram/claude-caliper100MIT
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 2edc3434f63c (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

  • 100brief
    Prowadzi małą zmianę od briefu przez wdrożenie i przegląd do weryfikacji, bez pliku planu.
  • 90c4-cook
    Realizuje plan etapami albo małą, jasno opisaną zmianę, weryfikując każdy etap i zapisując postęp w plikach planu.
  • 95arn-code-swift
    Szybko wdraża małą zmianę lub ulepszenie w 1 do 8 plikach z uwzględnieniem wzorców projektu, bez pełnego procesu Arness.
  • 90feature-sprint
    Realizuje małą albo średnią funkcję od początku do końca: rozeznanie, zmiany w wąskim zakresie, walidację i czyste dostarczenie.
  • 90task-implementation
    Wdraża kolejne niezakończone zadanie z PLAN.md w podejściu TDD: najpierw testy, potem kod, gotowy do przeglądu i commita.
  • 84implement-change
    Wdraża zatwierdzoną zmianę w jednej ciągłej sesji, uruchamiając testy w kilku poziomach.

Uwagi i zgłoszenia

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