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

loop-designer

/loop-designer

Zamienia jednorazowe zadanie w cykliczną autonomiczną pętlę: krótki wywiad o celu, źródłach, wyjściu i harmonogramie, a potem pięcioczęściowa specyfikacja z osobnym weryfikatorem.

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

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

Zamienia jednorazowe zadanie w cykliczną autonomiczną pętlę: krótki wywiad o celu, źródłach, wyjściu i harmonogramie, a potem pięcioczęściowa specyfikacja z osobnym weryfikatorem.

Oryginalny opis (EN)

Use this skill when the user says turn this into a loop, run this on a schedule, automate this daily, build me a loop, make this recurring, design a loop for a task, or loop this task — any request to make a one-off task a recurring autonomous job. Interviews minimally (goal, sources/inputs, output destination, schedule), then generates a five-part loop spec (Discover, Plan, Execute, Verify with a separate verifier checklist, Stop-or-Repeat), a non-negotiable guardrails block (max-iterations cap, cost ceiling, seen-log cross-run dedup, no-destructive-actions allowlist, completion/trip notifica

Jak działa

  1. Step 0 — Verification first
  2. Step 1 — Minimal interview
  3. Step 2 — Generate the loop spec (five parts, all explicit)
  4. Step 3 — Guardrails block (all five, always)
  5. Step 4 — Emit both artifacts, user picks one
  6. Hard rules
  7. Limitations
Sekcje z nagłówków SKILL.md, w oryginale · 89 linii, 985 słów
Podgląd SKILL.md
---
name: loop-designer
description: Use this skill when the user says turn this into a loop, run this on a schedule, automate this daily, build me a loop, make this recurring, design a loop for a task, or loop this task — any request to make a one-off task a recurring autonomous job. Interviews minimally (goal, sources/inputs, output destination, schedule), then generates a five-part loop spec (Discover, Plan, Execute, Verify with a separate verifier checklist, Stop-or-Repeat), a non-negotiable guardrails block (max-iterations cap, cost ceiling, seen-log cross-run dedup, no-destructive-actions allowlist, completion/trip notification), and two ready-to-paste runners — a Claude Code Routine prompt and a local cron/launchd variant. Do NOT use for improving an existing prompt ("improve this prompt" is prompt-optimizer-loop's job), for one-off tasks, for debugging an already-built loop, or to run something on an interval in the current session — the built-in /loop command does that; this skill designs durable guarded loops, it doesn't run them.
---

# Loop Designer

Turn a one-off task into a guarded autonomous loop: five explicit parts, five non-negotiable guardrails, two ready-to-paste artifacts. The architecture is generalized from a production daily-radar loop that has run live — see `references/loop-anatomy.md` for the anatomy and its provenance, `references/guardrail-design.md` for why each guardrail exists.

## Step 0 — Verification first

Before designing anything, ask: **what does a successful run look like, checkably?** If the user's task has no verifiable success condition ("keep an eye on things", "make it better over time"), stop and help define one — a file that exists with required fields, a count within bounds, a claim with a source link. No verifiable condition, no loop: an unverifiable loop cannot establish whether a run succeeded.

## Step 1 — Minimal interview

Ask only what the request didn't already say (one message, not a questionnaire):
1. **Goal** — the checkable success condition from Step 0.
2. **Sources/inputs** — what each run scans or consumes (URLs, repos, folders, APIs).
3. **Output destination** — where results land (file path pattern, branch, email, issue).
4. **Schedule** — cron-style cadence, or event-driven.

Before activation, confirm the timezone and numeric budgets with the owner.
If proposing defaults in a design, label them unapproved and keep them out of
executable configuration until accepted. Never imply a placeholder host tool
is installed or that a subscription has an API spending allowance.

## Step 2 — Generate the loop spec (five parts, all explicit)

```
LOOP SPEC: <name>
DISCOVER  — what each run scans, with recency/scope cutoffs stated
PLAN      — how findings are filtered and decomposed: dedup against the seen-log
            FIRST, then select/rank what survives (selection criteria explicit)
EXECUTE   — the action, with exact output format and destination
VERIFY    — a separate verifier checklist (3-6 binary checks) run AFTER execute;
            the run only counts as successful if every check passes
STOP-OR-REPEAT — exit conditions: work exhausted, nothing new found (say so
            honestly — an empty run writes "nothing new", never padding),
            iteration cap hit, or ceiling hit
```

Rules for VERIFY:
- The verifier is a **distinct step with its own checklist** — never the executor grading its own output in the same breath. In a Routine, VERIFY is a separately-delimited checklist pass over the artifact and remains self-review. Use a separate reviewer or deterministic checks when independence is required; record that boundary.
- Checks must be binary and artifact-inspectable (file exists, fields present, every claim has a source link, item count within bounds, no seen-log duplicates in output).
- A failed check = failed run, reported as such — never silently shipped.

## Step 3 — Guardrails block (all five, always)

Every generated loop includes this block verbatim-adapted — no omissions, no matter how simple the task:

```
GUARDRAILS (non-negotiable)
1. MAX ITERATIONS: <N> items/actions per run; stop and report when hit.
2. COST CEILING: <token/time budget> per run; stop and report when hit.
3. SEEN-LOG: each run starts stateless — cross-run memory lives in <path>
   (create if missing; read before acting; append after verification). Never
   re-process a logged item.
4. NO DESTRUCTIVE ACTIONS: never delete, overwrite, or send beyond this
   explicit allowlist: <allowlist>. Everything else is append/create-only.
5. NOTIFY: on completion AND on any guardrail trip or verify failure, emit
   the notification line to <channel>. Never fail silently.
```

Define overflow, retries and durable state explicitly. Never advance a discovery
cursor past unprocessed items. Specify pagination completion, concurrent-run
exclusion, an idempotent publication key and recovery after uncertain writes.
For repository PR workflows, verify before opening the PR; keep proposed log
entries in that PR and pause future runs while it is pending. A run date is not
an issue creation-time cursor. Notifications must stay inside the action allowlist.

## Step 4 — Emit both artifacts, user picks one

**(a) Claude Code Routine prompt** — a complete, standalone prompt for a scheduled cloud run (each firing starts from zero context, so the prompt carries everything: the five-part spec inline, the guardrails block, the seen-log path, the output destination). Ready to register with a cron expression.

**(b) Local cron/launchd variant** — a shell one-liner invoking `claude -p "<the same prompt>"` plus the crontab line (and the launchd plist snippet if the user is on macOS). Same prompt body — the runner is the only difference.

Label both clearly and tell the user to pick one; running both double-processes the seen-log.

## Hard rules

- **Never generate a loop without all five guardrails.** A request to skip one gets the reason it exists (from `references/guardrail-design.md`) and a loop that still includes it.
- **Do not claim independent verification from self-review.** A separate checklist in one model context does not establish independence. State who or what executes each check.
- **Verification first.** No verifiable success condition → help define one before generating; never emit a loop whose success can't be checked from its artifacts.
- **State lives in files.** Each scheduled run starts stateless; anything the loop must remember (seen items, counters, last-run date) is read from and written to files, never assumed from memory.
- **Honest empty runs.** A run that finds nothing new says so in one line and exits — padding an empty run is a verify failure.

## Limitations

- Generated loops are only as safe as their allowlist; the skill defaults to append/create-only and flags any user-requested destructive action for explicit confirmation rather than silently including it.
- Cost ceilings are stated as budgets in the prompt; scheduled runners don't hard-enforce token caps — the ceiling instructs the model to stop, it doesn't meter the account.
- The Routine artifact targets Claude Code scheduled runs; other schedulers (GitHub Actions, Airflow) need adaptation the skill will do on request but doesn't emit by default.
- A loop spec is a design, not a deployment: the skill doesn't register the Routine or install the crontab — it hands over paste-ready artifacts and exact registration steps.
Pliki w paczce (5)
  • SKILL.md 7 KB
  • examples/sample-loop-package.md 5 KB
  • examples/sample-request.md 1 KB
  • references/guardrail-design.md 3 KB
  • references/loop-anatomy.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · Abhillashjadhav/AI-PM-essential-skills100MIT
frankxai/claude-skills-library100MIT
evanca/ai-agent-skills90MIT

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

  • 100loop-or-not
    Rozstrzyga, czy zadanie w projekcie warto uruchamiać jako pętlę agenta: analiza repozytorium, krótki wywiad i werdykt z trzech opcji, czyli bez pętli, pętla czasowa lub pętla celu, z dowodami.
  • 95ralph-loop
    Uruchamia autonomiczną pętlę rozwoju, w której każda iteracja w świeżym kontekście wybiera jedno zadanie, implementuje je, weryfikuje i zatwierdza commitem.
  • 90goal-loop
    Prowadzi zadanie w pętli celów: spisuje kontrakt, wykonuje pracę, weryfikuje ją niezależnym agentem i powtarza do zaliczenia.
  • 100hermod
    Rejestruje w harmonogramie systemu (launchd lub crontab) w pełni autonomiczną pętlę Odin-Loop bez bramki człowieka do uruchamiania bez nadzoru, w tym nocnych przebiegów, i działa jako runner w chwili odpalenia.
  • 100loop-engineering
    Przekształca powtarzalne zadanie w ograniczoną pętlę Trigger, Execute, Verify, State, zaplanowaną automatyzację, agenta celu lub cykl badań sterowany metryką.
  • 87loop-forge
    Zamienia powtarzalne zadanie w komendę z ukośnikiem, dodając niezależnego weryfikatora i twardy limit budżetu lub liczby kroków.

Uwagi i zgłoszenia

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