Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

cdev

/cdev

Uruchamia autonomiczną pętlę wykonawczą aktywnego sprintu w repozytorium, także nocą, bez nadzoru.

Repozytorium
cdev ↗
Licencja
MIT
Ostatnia zmiana repozytorium
20.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 20.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

Uruchamia autonomiczną pętlę wykonawczą aktywnego sprintu w repozytorium, także nocą, bez nadzoru.

Wyzwalacze z opisu

follow the plansigue el plan
Oryginalny opis (EN)

Use when the user invokes /cdev (with or without arguments) in a repo conditioned for continuous autonomous development, or asks to run the active sprint, "follow the plan", "sigue el plan", or overnight/unattended work — starts the single execution loop, adapted through the role profile the repo resolves to.

Jak działa

  1. Resolve the role
  2. Start (every invocation/resumption)
  3. Loop (repeat until a real blockage)
  4. Auto-advance
  5. It only stops when
  6. Safety gates (never elevated)
  7. Optional composition (host bindings)
Sekcje z nagłówków SKILL.md, w oryginale · 113 linii, 1 019 słów
Podgląd SKILL.md
---
name: cdev
description: Use when the user invokes /cdev (with or without arguments) in a repo conditioned for continuous autonomous development, or asks to run the active sprint, "follow the plan", "sigue el plan", or overnight/unattended work — starts the single execution loop, adapted through the role profile the repo resolves to.
---

# CDev — the execution loop

Single entry point, single loop. Invoking it is the **elevated autonomy** mandate: work
proactively assuming what the project needs and stop **only at real blockages** — never to ask
what to do next.

The repo is the memory: `SPRINTS.md` = plan · `AGENT_PROGRESS.md` = handoff · git = state. The
repo's specifics live in its `docs/develop/AGENT_EXECUTION_PROTOCOL.md`; the role's specifics
live in a **role profile**; this skill is the generic operating system and the autonomy
threshold. If the repo's protocol is stricter about *when to stop and ask*, this explicit
invocation elevates it; on safety gates the strictest always wins.

## Resolve the role

Read the repo guide (`AGENTS.md`; hosts with their own filename read it through a pointer,
e.g. `CLAUDE.md`) and `docs/develop/` (RECOGNITION document if present, protocol).
Then load the matching profile from this package's `profiles/` directory: resolve this skill's
base directory to its **real path first** (dereference junctions/symlinks), then go to
`../../profiles/`:

- **Backend** (API/services/own schema, no UI) → `profiles/backend.md`.
- **Frontend** (consumes an external backend) → `profiles/frontend.md`.
- **Fullstack/other** → no profile ships: the repo's own protocol must supply the four things a
  profile would (what "verified" means, what "evidence" means, the hardest gate, the
  self-chosen work order). Same loop, same contract. When in doubt, what the repo declares wins.

A profile supplies **exactly those four things** and can never alter the loop, the stop
conditions, the autonomy threshold or the gate policy.

**Not conditioned** (no `docs/develop/` with SPRINTS/protocol) → do not improvise the loop:
propose the `bootstrap` skill and stop there.

## Start (every invocation/resumption)

Read in order: the repo guide (`AGENTS.md`) → protocol → `SPRINTS.md` → `AGENT_PROGRESS.md` (latest entry) →
`git status` + recent commits. If the repo declares an upstream contract (a consumed producer's
published report), read it **before** starting the sprint: it is the contract — never invent
fields, and record divergence from deployed reality as a blocker/decision, not a guess. Resume
from there; do not re-derive what was already decided.

If git shows real work the plan does not know about (commits/WIP with no batch or progress
entry), **reconcile first**: reflect it in `SPRINTS.md` + `AGENT_PROGRESS.md` before
continuing — repo-as-memory does not function while plan and code disagree.

**No argument** = resume the plan's pending work. **With argument** = same loop scoped to that
focus (e.g. `/cdev sprint 09`).

## Loop (repeat until a real blockage)

1. **Select:** first `READY`/`IN_PROGRESS` batch of the `ACTIVE` sprint, in strict declared
   order. Mark it `IN_PROGRESS`. Working branch per the repo's convention; default when the
   repo declares none: `cdev/sprint-<nn>-batch-<nn>`, numbering matching the plan's own. A
   batch depending on an unmerged predecessor branches from that predecessor's branch (merging
   is a human gate, so stacking is the only way to see its work). Never a shared branch.
2. **Implement only that batch.** Reuse before writing; smallest correct diff; additive by
   default so live contracts do not break.
3. **Verify** with the real sequence — the profile defines what "verified" means for the role,
   the protocol fixes the exact commands. If a declared check turns out not to be a real gate
   (it passes while checking nothing), record it as pass-with-caveat and raise a blocker to
   fix the gate — a gate that lies is worse than none. Steps whose blast radius exceeds the
   working branch are prepared, never executed (§ gates).
4. **On failure, diagnose before fixing:** exact error quoted, find every caller, fix the root
   cause once where they all route through, re-run the failed command and then the full
   sequence. Never silence a check to make a step pass.
5. **Record** in `AGENT_PROGRESS.md`, in the ordering the protocol declares: honest status,
   what was done, files, verification **pass/fail/not-run per check**, blockers each naming
   the minimum human decision, next. Incomplete is never `DONE`.
6. **Commit the whole batch** on its branch, unit in the message; useful-but-unfinished →
   `wip(...)`. Never push.
7. **Close:** `DONE` only when acceptance is met with recorded evidence — evidence as the
   profile defines it. Next batch.

## Auto-advance

- **Batch done** → next batch of the sprint.
- **Batch blocked (non-quota)** → `BLOCKED` with reason + the minimum human decision, then
  *blocked-but-not-idle*: next batch whose dependencies are met; if none, the next independent
  sprint. Blocked work is never quietly closed.
- **Sprint done** → if the repository has downstream consumers, publish the contract delta
  where they look (the repo's report convention) as part of closing; mark `DONE`, promote the
  next `PENDING` to `ACTIVE`, continue.
- **Plan exhausted** → derive the next work yourself in the profile's self-chosen order,
  staying inside DEFINED/PARTIAL areas of the clarity map (`PRODUCT.md`; if the repo has no
  map yet, approximate — defined = existing source doc + contract — and note it in
  `docs/develop/DECISIONS.md`). A next-phase draft is written as `PROPOSAL`, never self-activated; continue
  with the other work meanwhile. Record what was self-chosen and why.

## It only stops when

- No ungated work remains anywhere — say exactly which approvals would unblock what.
- A safety gate requires human action and everything else depends on it.
- Contradictory docs, or an `ABSENT` area without which it cannot continue (open question
  recorded; inventing product is forbidden).
- The repo is in an unsafe state.
- Usage/quota limit: save everything, update `AGENT_PROGRESS.md`, commit what is safe (`wip`
  if needed), exit cleanly. Resumption reads the repo, never conversational memory.

## Safety gates (never elevated)

The shape is core: **blast radius beyond the working branch** (push to shared branches, merge,
PRs, deploy, history rewriting) · **irreversible on shared state** (remote schema apply,
destructive data operations) · **real money and live credentials**. The repo's protocol lists
its own gates; the profile lists the role's typical ones; the union applies and the strictest
wins. Prepare, don't execute: draft + blocker naming the decision. A past authorization
recorded in the repo is never a present one.

## Optional composition (host bindings)

If available in the host, compose: a minimal-diff discipline at every step, test-driven work on
domain logic, systematic debugging on failures, a verification pass before claiming done. The
rules above stand on their own without any of them.

Wersje

W bazie nie ma innych skilli o nazwie cdev.

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

  • 90bootstrap
    Przygotowuje repozytorium do ciągłego autonomicznego rozwoju: dokumentację w docs/develop i ponowny audyt istniejącego repo.
  • 90cdev-planner
    Dzieli cel na partie zadań w pliku SPRINTS.md i przeszukuje repozytorium pod kątem luk w planie.
  • 100ql-execute
    Uruchamia autonomiczną pętlę wykonawczą: czyta quantum.json, odpytuje graf zależności i implementuje historyjki z TDD oraz dwuetapowym przeglądem, także równolegle w osobnych worktree.
  • 100writing-char-drivers
    Pomaga pisać sterowniki urządzeń znakowych w jądrze Linuksa: file_operations, cdev, kopiowanie danych do przestrzeni użytkownika, ioctl i mmap.
  • 100autopilot-plan
    Zamienia dużą zmianę w plan autopilota z SPEC.md i tasks.json, który wykonuje się bez nadzoru w wielu sesjach.
  • 100run
    Uruchamia bez nadzoru zatwierdzony plan w projekcie z .foreman.toml, pojedynczo lub jako łańcuch planów, od miejsca wznowienia do końca.

Uwagi i zgłoszenia

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