load-bearing

load-bearing

!checklist init ${CLAUDE_SKILL_DIR} --force

Architecture is the set of decisions that are expensive to reverse. That definition is the whole skill — and it is exactly what the agent-assisted era changes the calculus of. When an agent (or a fleet of them) writes the code, the cost of reversible decisions — how the internal code is organized, which library you reached for, even a full rewrite — collapses toward zero. The cost of irreversible decisions — a production data schema, a public contract others depend on, the trust/security model, the line where you split into separate deployables — does not budge. Agents make code cheap to change; they do not make data migrations, broken API contracts, or breaches cheap.

So the master move of this skill is a triage: spend your scarce human judgment on the one-way doors, and let agents move fast and refactor freely behind the two-way doors. Most of the classic "decide it carefully up front" advice was written when all code was expensive to change. Half of it now applies only to the durable layer.

Speak the owner's language, or the one-way door isn't theirs. This skill works by spending the user's judgment where you cannot reverse it — validating an inherited decision, approving or vetoing an ADR — and they can only judge a decision they follow. Read their fluency from how they talk, and gloss a term on first use (SSRF, CAP, idempotent, a discriminated union). An owner nodding at an ADR they did not parse hasn't approved that door — they've abdicated it, the exact irreversible mistake this skill exists to prevent.

This skill walks a six-stage flight plan and will not fly past a GATE until it is cleared.

Discipline: finish every GATE before the next stage. GATEs are hard — never skip, batch past, or self-certify a stage you have not done. The checklist tool enforces the order; let it. Commands address stages by name.

Read references/agent-era-shifts.md first. It is the heart of this skill: the seven ways architecture in the agent era differs from the textbook, each with the design consequence. The human-era canon (Conway, Monolith First, DDD, CAP, ADR, KISS/YAGNI) is all still here — but re-aimed for a world where the code is written by something that has no instinct to respect a boundary, feels no cost producing complexity, and forgets everything between sessions.

This stage consumes the output of the groundwork skill — the funded requirements, the non-functional requirements, and the scope. If that does not exist yet, get it first; designing against unstated requirements is the original sin. If $ARGUMENTS is a trivial, structurally-settled change, this skill is overkill — say so and proceed.