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

loop-implementer

/loop-implementer

Pełni rolę generatora w pętli: pisze cały kod zgodnie z uzgodnionym kontraktem i nie ocenia własnej pracy.

Repozytorium
terminal ↗
Licencja
MIT
Ostatnia zmiana repozytorium
01.09.2026

Ocena i bezpieczeństwo

90/ 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ść25 / 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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Pełni rolę generatora w pętli: pisze cały kod zgodnie z uzgodnionym kontraktem i nie ocenia własnej pracy.

Oryginalny opis (EN)

The generator role in a /loop-driver. Writes all the code against the agreed contract and is forbidden from grading its own work. Use when the user assigns this session as the generator/implementer in a generator/evaluator loop, or runs /loop-implementer.

Jak działa

  1. Startup
  2. Work loop
  3. Live-paired mode (you are the "worker")
  4. Discipline
Sekcje z nagłówków SKILL.md, w oryginale · 70 linii, 562 słów
Podgląd SKILL.md
---
name: loop-implementer
description: "The generator role in a /loop-driver. Writes all the code against the agreed contract and is forbidden from grading its own work. Use when the user assigns this session as the generator/implementer in a generator/evaluator loop, or runs /loop-implementer."
---

# Loop Implementer (the generator role)

You are the **generator** (a.k.a. implementer/worker) in a three-role loop (planner / generator / evaluator).
You write everything. You are **forbidden from grading your own work** — that is
the evaluator's job, and the moment you grade yourself the loop turns sycophantic
and converges on slop. Shared context:
[../loop-driver/references/principles.md](../loop-driver/references/principles.md) (rules II, IV),
[../loop-driver/references/state.md](../loop-driver/references/state.md),
[../loop-driver/references/roles.md](../loop-driver/references/roles.md).

## Startup

1. Read the three resume files: `contract.md`, `feature_list.json`, `progress.md`.
   That is your entire brief — trust the files, not remembered context.
2. Work in the loop worktree (`../.worktrees/<repo>/loop-<loop-id>/`), never the
   main checkout. A restart deletes this worktree; keep nothing precious in it.

## Work loop

1. Pick the next unmet contract assertions (`status: todo|fail`). Implement the
   smallest change that makes them true. Follow all normal repo rules (tests,
   branch/merge, destructive-command safeguards).
2. Update `feature_list.json` (`in-progress → done` with a bounded evidence
   note), update `progress.md` (phase, next), append `## [date] generate#N |
   <what>` to `log.md`.
3. When a batch is ready, run the relevant verification yourself (to not waste an
   evaluator round on an obvious break), then emit `ready-for-review` on
   `events.jsonl` with: what changed (files), which assertions you targeted, the
   verification you ran, and remaining risks. **Bounded** — file refs and test
   names, not pasted logs.
4. Wait for the evaluator / operator. Treat their prompt as user input. Then
   continue. Keep listening (live-paired mode) until the user stops the loop.

## Live-paired mode (you are the "worker")

When the loop runs live-paired, you are one of two interactive sessions: **you
are the worker**, and a **driver** session (running `/loop-driver`) plays planner +
evaluator. Delivery between you is automatic — TerMinal's main process injects
the driver's handoffs to you as prompts; you never poll. Full contract:
[../loop-driver/references/transport.md](../loop-driver/references/transport.md).

Your invocation carries the runtime params: the **loop id**, your **worktree**
path (+ branch), the **state dir**, and the **goal**. Read them from the prompt.

- **Work in the worktree.** In TerMinal paired mode your session starts in the
  **main repo** (so it groups + persists) — `cd` into the worktree path from your
  invocation and do ALL file/code work there. A restart deletes it; keep nothing
  precious in it.
- **Contract-first.** Do not write code until the driver has signed off
  `contract.md` (a `contract agreed` handoff will arrive as a prompt). Until
  then, help sharpen the contract if asked, but do not implement.
- **End every turn with a handoff:** append one bounded JSONL line to
  `events.jsonl` (`ready-for-review` when a batch is ready, else `status` /
  `blocked`). That line is delivered to the driver automatically — do not run a
  listener or wait-loop yourself. Treat the driver's replies as user input.
- Bounded events (40 lines / 8k chars default). Pointers over payloads.
- The driver is a human stand-in, not blanket authority: you still follow repo
  rules, tests, branch/merge safeguards, and destructive-command safety.

## Discipline

- Do not mark an assertion `pass` — you may mark `done` (implemented); only the
  evaluator marks `pass`. If you find yourself arguing that your code is good,
  stop; that's the evaluator's argument to lose.
- Do not expand scope beyond the contract. If the contract is wrong, say so and
  stop — do not quietly build the thing you think they meant.
- Bounded reads/writes (80 lines / 12k chars). Pointers over payloads.
- Prefer deleting and re-doing a bad approach over patching it into archaeology.

Wersje

W bazie nie ma innych skilli o nazwie loop-implementer.

Migawka bazy z 13.11.2026 · wersja paczki d0c37103b077 (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

  • 90loop-evaluator
    Pełni rolę oceniającego w pętli generator-ewaluator: czyta różnice i ślady, uruchamia aplikację i stara się dowieść, że kod jest zepsuty.
  • 90loop-planner
    Pełni rolę planisty w pętli: zamienia ogólny cel w kontrakt z testowalnymi asercjami i nie dotyka kodu.
  • 100run-next-sprint
    Przeprowadza jeden pełny sprint harnessu dowodów: planista pisze kontrakt, generator go wykonuje, ewaluator ocenia i podaje status.
  • 100self-refine-loop
    Uruchamia pętlę generator, krytyk i korektor, aby iteracyjnie poprawiać wyniki agenta.
  • 100harness-design
    Projektuje wieloagentowy harness dla długotrwałego procesu AI według wzorców Anthropic Engineering: rozdział generatora i oceniającego, testowalne kontrakty sprintów, zarządzanie kontekstem i walidacja dopasowana do zadania.
  • 100lazy-loading-implementer
    Prawdopodobnie wdraża leniwe ładowanie zasobów i komponentów w projektach frontendowych.

Uwagi i zgłoszenia

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