Skip to content
Skills Library
Programming · Automation

cdev

/cdev

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.

Repository
cdev ↗
Licence
MIT
Last repository change
20.09.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 20.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Triggers from the description

follow the plansigue el plan
Original author 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.

How it works

  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)
Original SKILL.md headings · 113 lines, 1,019 words
SKILL.md preview
---
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.

Versions

The database has no other skills named cdev.

Database snapshot: 13.11.2026 · package version 14ab2f11aedd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90bootstrap
    Use when a repository must be conditioned for continuous autonomous development (CDev) — a new repo, an existing one without docs/develop/, or a re-audit of one already conditioned; when the user asks to "bootstrap", "condition this repo for cdev", "prepare it so /cdev can work…
  • 90cdev-planner
    Use when planning work inside a single CDev-conditioned repository — turning an objective into batches in the local SPRINTS.md with observable acceptance, or sweeping the repo for gaps (verification debt, stale blocks, coverage/parity holes, plan↔git divergence, contradictory…
  • 100ql-execute
    Part of the quantum-loop autonomous development pipeline (brainstorm \u2192 spec \u2192 plan \u2192 execute \u2192 review \u2192 verify). Run the autonomous execution loop. Reads quantum.json, queries the dependency DAG, implements stories with TDD and two-stage review gates.…
  • 100writing-char-drivers
    Character driver skill for Linux kernel char devices. Use when implementing file_operations, cdev, copy_to_user, ioctl, or mmap for userspace interfaces. Activates on queries about char device, cdev, file_operations, copy_from_user, ioctl, or kernel mmap.
  • 100autopilot-plan
    Turn a large change into an autopilot plan (SPEC.md + tasks.json) that the `autopilot` orchestrator runs unattended across many Claude Code sessions, each with its own model and effort. Use when the user runs /autopilot-plan or asks to plan work for an overnight or unattended run.
  • 100run
    Start an unattended run on an approved plan, in a project that has a .foreman.toml. Takes a plan file, or several plan files to run as a chain one after the other, and optionally the units to run; with no units it runs everything from each plan's resume point to the end. Use…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.