git:20260815.6e00d66 to git:20260815.3aeef27

---

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

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)

`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.