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.
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 20.09.2026, without references to retired models or APIs.
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
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
- Resolve the role
- Start (every invocation/resumption)
- Loop (repeat until a real blockage)
- Auto-advance
- It only stops when
- Safety gates (never elevated)
- Optional composition (host bindings)
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…