git:20260815.6dcb086 to git:20260815.76bf085

---

name: bootstrap

description: 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 alone", "condicionar para cdev" — for any role (backend, frontend, other), with or without a folder of source docs.

---

# Bootstrap (CDev)

Conditions one repository for autonomous execution with an **elevated autonomy threshold**: the

agent that later runs `/cdev` stops only at real blockages, never to ask "now what?". Two

mandatory halves — skipping the second is what makes autonomy dangerous:

- **Half A — Structure:** write the CDev machinery into the repo, adapted to what the repo

actually is.

- **Half B — Clarity:** audit how far it is clear *what* must be produced; clarity bounds

autonomy.

Idempotent: on an already conditioned repo it acts as an audit and proposes diffs, never

overwrites silently.

Base material: the package's `templates/` (placeholder contract in `templates/PLACEHOLDERS.md`;

zero unresolved `{{` at the end) and the role profiles in `profiles/` — resolve this skill's

base directory to its **real path first** (dereference junctions/symlinks), then both live at

`../../` from there.

## Resolve the role

Inspect before assuming: own schema/services and no UI → **backend** (`profiles/backend.md`);

consumes an external backend and renders UI → **frontend** (`profiles/frontend.md`); both or

neither → **other**: no profile ships — the conditioning itself must write into the repo's

protocol the four things a profile would supply (what "verified" means, what "evidence" means,

the hardest gate, the self-chosen work order). What the user declares wins over the guess.

## Half A — Structure

1. **Recognize before writing.** Read the real repository: stack, manifest and lockfile, real

scripts, schema/migrations, targets, existing guides and docs. Write the **recognition

document** (`docs/develop/RECOGNITION.md`): what the repo actually is, its real architecture

patterns (extracted from code, they exist nowhere else), and **every place a generic

assumption must be overridden**. A conditioning that renders templates without this step

produces a plan for a repository that does not exist.

While reading, **check the repo's operational documents against each other** (runbooks,

deploy docs, existing guides): the loop trusts instructions, so two documents disagreeing

about the same switch is an incident waiting. A contradiction found is resolved with the

human or recorded as an open question — never left standing.

2. **Materialize the role profile into the repo's protocol.** The profile brings the role's

four things; conditioning makes them concrete here:

- **Verification** (profile §1): fix the exact sequence from the repo's real scripts — and

**verify each gate before trusting it**; the profile lists the role's known traps (gates

that lie, missing frameworks). A missing mandatory gate becomes the plan's first batch or

a written blocking requirement, never an omission.

- **Evidence** (profile §2): write what a `DONE` must prove here, and with which tooling;

missing tooling is a written blocking requirement.

- **Hardest gate** (profile §3): perform the role's classification (e.g. the database's

shared-vs-ephemeral nature, the consumed backend's contract and pins) and write the

resulting gates into guide + protocol.

- **Self-chosen work order** (profile §4): write it into the protocol's stop-conditions

section — when the plan runs out the agent derives next work itself in that order and

stops only at real blockages. This is what legitimizes `/cdev` not stopping.

3. **Render the core artifacts** from `templates/`, resolving every placeholder: repo guide

(`CLAUDE.md`), `docs/develop/` (protocol with local deltas only, SPRINTS, PROGRESS,

DECISIONS, PRODUCT). The handoff log's ordering is **declared explicitly in the protocol**

(default: newest-first). Optional on request: TESTING, RUNBOOK, ROADMAP, ARCHITECTURE, and

the night-runner script (a quota-resumption convenience only — the primary loop is the

reviewer/runner agent templates and the per-repo runtime skills — unevidenced in six weeks

of field use; render them only if the repo asks for them. The greenfield conditioning-plan

document is gone entirely.

4. **Existing files are never clobbered:** diff and ask, file by file.

## Half B — Clarity

1. **Source inventory.** Product/spec docs, designs, contracts (a consumed producer's schema or

reports), READMEs, existing code. Order by authority.

2. **Score every domain area:**

- `DEFINED` — spec + derivable acceptance criteria (for a consumer role: the upstream

contract exists too). The agent may work it alone.

- `PARTIAL` — intent clear, detail ambiguous — or the upstream contract is missing, which

caps an area at PARTIAL. Work the clear part; every assumption recorded in DECISIONS.

- `ABSENT` — only the name exists. Inventing it is forbidden: open question, never a batch.

3. **Write the clarity map** in `docs/develop/PRODUCT.md` (table: area → level → source → open

questions). It is the boundary of autonomy: `/cdev` self-selects work only inside

DEFINED/PARTIAL.

4. **Derive SPRINTS.md as far as clarity reaches.** Sprint 01 `ACTIVE`, Batch 01 `READY`,

observable acceptance written before the work (including the role's required evidence).

PARTIAL areas → batches with assumptions noted; ABSENT → open question only.

## Human gate (single)

Before writing any file: present the resolved-placeholder table + the clarity map + the

phase/sprint outline. One confirmation (or edits), then write everything.

## Safety gates the bootstrap leaves written (non-negotiable)

The core shape — blast radius beyond the working branch, irreversible operations on shared

state, real money and live credentials — plus the role's typical list from profile §3, made

concrete for this repo. The elevated profile raises *what to work on*, never these.

## On finishing

Validate: zero unresolved `{{`, exactly one `ACTIVE` sprint (`scripts/verify-bootstrap.ps1`

automates both). Seed the first `AGENT_PROGRESS.md` entry (bootstrap done, Sprint 01 ACTIVE,

uncommitted WIP under the first batch), and print a "conditioned — how to launch" summary.