Przejdź do treści
Biblioteka skilli
Produktywność osobista · Automatyzacja

refine-loop

/refine-loop

Prowadzi iteracyjne samodoskonalenie rezultatu (dokumentu, implementacji, promptu lub projektu) aż do spełnienia kryteriów ukończenia.

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

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

Prowadzi iteracyjne samodoskonalenie rezultatu (dokumentu, implementacji, promptu lub projektu) aż do spełnienia kryteriów ukończenia.

Argumenty

/refine-loop <task>" --until "<criteria>" [--max <N>] [--autonomous]
Oryginalny opis (EN)

Use when the user wants iterative self-improvement on a deliverable (document, implementation, prompt, design) until completion criteria are met.

Jak działa

  1. refine-loop
  2. Argument Parsing
  3. Failure State Persistence
  4. Process
  5. Diminishing Returns Detection (Autonomous Mode)
  6. Safety
  7. When to Use
  8. When NOT to Use
Sekcje z nagłówków SKILL.md, w oryginale · 151 linii, 790 słów
Podgląd SKILL.md
---
name: refine-loop
version: 2.5.0
description: Use when the user wants iterative self-improvement on a deliverable (document, implementation, prompt, design) until completion criteria are met.
trigger: manual
depends-on: []
references: []
user-invocable: true
allowed-tools: Read, Glob, Grep, Bash, Edit, Write
argument-hint: ""<task>" --until "<criteria>" [--max <N>] [--autonomous]"
---
______________________________________________________________________

## refine-loop

Refining: **$ARGUMENTS**

## Argument Parsing

| Argument | Required | Default | Description |
|----------|----------|---------|-------------|
| `<task>` | Yes | - | What to produce or improve |
| `--until "<criteria>"` | Yes | - | Completion condition (must be verifiable) |
| `--max <N>` | No | 5 (50 if `--autonomous`) | Maximum iterations before stopping |
| `--autonomous` | No | false | Extended unattended mode: higher iteration cap, TSV logging, diminishing-returns auto-stop |

## Failure State Persistence

At loop entry, write `docs/sessions/.failure-state.md` with YAML frontmatter so the Stop hook and `/continue` can programmatically detect incomplete workflows.

**At loop entry** (before first execution):

```yaml
---
status: active
skill: refine-loop
phase: "1"
phase_name: "Initial Execution"
started_at: "[ISO-8601 timestamp from date -u +%Y-%m-%dT%H:%M:%SZ]"
story: "[from $ARGUMENTS — the task description]"
branch: "[from git branch --show-current]"
next_action: "Execute task and produce first draft"
autonomous: [true|false]
files_modified: []
---

## Context
Task: [task description]
Criteria: [completion criteria]
Iteration: 1 of [max]
Mode: [standard | autonomous]
```

**At each iteration:** Update `phase` to the iteration number, `phase_name` to `"Iteration N"`, `next_action` to the specific improvement being applied, and append to `files_modified`. Update the Context section with iteration progress and remaining gaps.

**When criteria are met (or max iterations reached):** Delete `.failure-state.md` — clean state means no failure to recover from.

## Process

### 1. Initial Execution

Execute the task to produce the first draft/version.

**If `--autonomous`:** Initialize the iteration log file:
```
docs/sessions/.refine-log.tsv:
iteration	criteria_met	criteria_total	gap_description	action_taken	timestamp
0	0	<total>	Initial execution	Produced first draft	<ISO-8601>
```

### 2. Self-Review Against Criteria

Evaluate the current output against the completion criteria. For each criterion:
- **MET**: Criterion is satisfied with evidence
- **NOT MET**: Criterion fails — identify the specific gap

### 3. Decision Point

```
[All criteria MET?]
  → YES: Output final result → DONE
  → NO: [iterations < max?]
    → YES: Identify SPECIFIC improvements → Apply → Go to step 2
    → NO: Output best result + remaining gaps → DONE
```

**Autonomous mode additional check:** Before continuing to next iteration, check for diminishing returns (see Diminishing Returns Detection below).

### 4. Iteration (if continuing)

Each iteration MUST:
1. **Name the gap**: What specific criterion is not met?
2. **Describe the fix**: What concrete change will address it?
3. **Apply the fix**: Make the change
4. **Re-evaluate**: Check ALL criteria again (not just the one fixed)

<HARD-GATE>
Each iteration must identify SPECIFIC improvements with concrete descriptions. "Make it better" or "improve quality" are NOT valid improvement descriptions. If you cannot name a specific gap, the loop is done — output the current result.
</HARD-GATE>

**If `--autonomous`:** After each iteration, append to `docs/sessions/.refine-log.tsv`:
```
<iteration>	<criteria_met_count>	<criteria_total>	<gap_addressed>	<action_taken>	<ISO-8601>
```

### 5. Completion Report

```markdown
### Refinement Complete

**Task:** [description]
**Completion criteria:** [criteria]
**Iterations:** X of Y max
**Mode:** [standard | autonomous]
**Status:** [All criteria met / Stopped at max / No further improvements identified / Stopped: diminishing returns]

**Iteration log:**
1. [What was changed and why]
2. [What was changed and why]
...

**Remaining gaps (if any):**
- [Gap]: [Why it couldn't be resolved]
```

## Diminishing Returns Detection (Autonomous Mode)

When `--autonomous` is active, track progress across iterations:

**Trigger:** 3 consecutive iterations where `criteria_met` count does not increase.

**Action:**
1. Print: "Diminishing returns: 3 consecutive iterations with no criteria progress."
2. Attempt ONE strategy shift — try a fundamentally different approach to the remaining gaps
3. If the next iteration ALSO shows no progress: stop the loop early
4. Report: "Stopped early: diminishing returns after [N] iterations"

**Why this exists:** In autonomous mode, the iteration cap is high (50). Without diminishing-returns detection, the loop could spend 40+ iterations making no meaningful progress. This auto-stop preserves context budget for productive work.

## Safety

- Default `--max 5` prevents runaway loops (raised to 50 only with explicit `--autonomous`)
- Each iteration must make measurable progress — if an iteration doesn't change anything, stop
- If the same gap persists after 2 attempts, flag it as potentially unresolvable and move on
- The loop produces a completion report regardless of how it ends
- **Autonomous mode:** Diminishing-returns detection auto-stops after 3+ consecutive no-progress iterations

## When to Use

- Polishing documentation (architecture docs, READMEs, ADRs)
- Iterating on prompt/skill content
- Refining complex implementations with multi-faceted quality criteria
- Any task where "good enough on first try" is unlikely
- **With `--autonomous`:** Long-running refinement tasks (test suite generation, comprehensive documentation, prompt optimization) where extended unattended iteration is acceptable

## When NOT to Use

- Simple one-shot tasks (just do them directly)
- Tasks without clear completion criteria
- During story-cycle execution (use the story-cycle's own phases instead)
- **`--autonomous` specifically:** When each iteration requires human judgment or approval

Wersje

RepozytoriumWynikLicencja
Ta strona · joris887/exosuit100MIT
juw12/skills100MIT

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

  • 100iterative-loop
    Uruchamia ciągłe pętle iteracji AI, powtarzające cykle budowania, testu i poprawki aż do spełnienia kryteriów sukcesu, przy zadaniach z jasnym kryterium zaliczenia.
  • 100loop-engine
    Prowadzi zadanie przez iteracje: analizę, rozpoznanie projektu, porównanie rozwiązań, wdrożenie, weryfikację i przegląd, aż do spełnienia warunków.
  • 100verification-loop
    Prowadzi iteracyjne cykle weryfikacja-naprawa dla buildu, typów, lintu, testów i bramek bezpieczeństwa.
  • 100design-review-iterative
    Prowadzi iteracyjny przegląd dokumentu projektowego z malejącymi progami poprawek, po napisaniu dokumentu lub na prośbę o przegląd projektu.
  • 95Loop
    Prowadzi pętlę iteracyjnego ulepszania wybranego celu przez kolejne cykle algorytmu w stronę stanu idealnego, gdy coś trzeba dopracować w wielu przebiegach.
  • 100self-refine-loop
    Uruchamia pętlę generator, krytyk i korektor, aby iteracyjnie poprawiać wyniki agenta.

Uwagi i zgłoszenia

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