Invoke repository skills with $skill-name in Codex; this mirrored copy rewrites legacy Claude /skill-name references.
Task tracker mandate: BEFORE executing any workflow or skill step, create/update task tracking for all steps and keep it synchronized as progress changes.
User-question prompts mean to ask the user directly in Codex.
Ignore Claude-specific mode-switch instructions when they appear.
Strict execution contract: when a user explicitly invokes a skill, execute that skill protocol as written.
Subagent authorization: when a skill is user-invoked or AI-detected and its protocol requires subagents, that skill activation authorizes use of the required spawn_agent subagent(s) for that task.
Do not skip, reorder, or merge protocol steps unless the user explicitly approves the deviation first.
For workflow skills, execute each listed child-skill step explicitly and report step-by-step evidence.
If a required step/tool cannot run in this environment, stop and ask the user before adapting.
Codex Project-Reference Loading (No Hooks)
Codex uses static project-reference loading instead of runtime-injected project docs.
When coding, planning, debugging, testing, or reviewing, open project docs explicitly using this routing.
Always read:
docs/project-config.json (project-specific paths, commands, modules, and workflow/test settings)
docs/project-reference/docs-index-reference.md (routes to the full docs/project-reference/* catalog)
docs/project-reference/lessons.md (always-on guardrails and anti-patterns)
Missing/stale context route: If docs/project-config.json, the docs index, lessons.md, CLAUDE.md, AGENTS.md, or any task-required reference doc is missing or stale, auto-run $project-init or the narrow setup route ($project-config, $docs-init, $scan-all, $scan --target=<key>, $claude-md-init) before ordinary project-specific work. If Codex mirrors or AGENTS.md are missing/stale, ask the user to run $sync-codex; do not auto-run it.
Situation-based docs:
Project structure/architecture/tech-stack/deployment/setup (any layer — backend, frontend, or infra): project-structure-reference.md
Spec authoring, docs/specs/ pathing, or TC format: feature-spec-reference.md, spec-system-reference.md, spec-principles.md
Behavior/public-contract changes or spec-test-code sync: workflow-spec-test-code-cycle-reference.md plus the spec docs above
Derived spec indexes/ERDs/reimplementation guides: spec-system-reference.md and source Feature Specs under docs/specs/
Integration test implementation/review: integration-test-reference.md
E2E test implementation/review: e2e-test-reference.md
Code review/audit work: code-review-rules.md plus domain docs above based on changed files
Do not read all docs blindly. Start from docs-index-reference.md, then open only relevant files for the task.
[BLOCKING] Execute skill steps in declared order. NEVER skip, reorder, or merge steps without explicit user approval.
[BLOCKING] Before each step or sub-skill call, update task tracking: set in_progress when step starts, set completed when step ends.
[BLOCKING] Every completed/skipped step MUST include brief evidence or explicit skip reason.
[BLOCKING] If Task tools are unavailable, create and maintain an equivalent step-by-step plan tracker with the same status transitions.
Quick Summary
Goal: Generate and validate the project's architecture scaffolding — all base classes, interfaces, infrastructure abstractions, and reusable foundation code — BEFORE any feature story implementation begins, producing a copy-ready, OOP/SOLID-compliant architecture foundation with quality-gate tooling that every feature story reuses before implementation starts.
Summary:
Gate-first: check Activation Guards before any work — proceed ONLY in workflow-greenfield-init / workflow-big-feature AND when grep finds NO existing base/abstract/infrastructure scaffolding; otherwise SKIP and mark the step completed.
Main steps (do ALL, in order): (1) Read Plan — parse tech stack, architecture decisions, domain model; (2) Generate Scaffolding Checklist from the Backend + Frontend/UI categories; (3) Validate Against Plan — every architecture decision has a scaffolding item; (4) Present to User by asking the user directly to confirm the checklist; (5) Scaffold — create all base classes, interfaces, abstractions, infra code + the 5 production-readiness foundations; (6) Verify — build/compile + OOP/SOLID compliance + Verification Gate. Then invoke $linter-setup → $harness-setup, then ask the user directly handoff.
Scope: architecture-infrastructure creation (base classes, interfaces, DI, repos, cross-cutting), NOT feature implementation — checklists are TEMPLATES: adapt naming to the detected tech stack, skip irrelevant items, add plan-specific ones.
Production-readiness: stand up all 5 foundations (code-quality tooling, error handling, loading state, Docker, integration points) and delegate ALL sensor setup to $linter-setup then $harness-setup — never hand-configure linters/hooks here. — why: a checklist of installs is not a harness.
Hard gate: enforce OOP/SOLID on every base class and HARD-BLOCK the handoff to $feature-implement until the Verification Gate passes — all 5 foundations verified plus $linter-setup and $harness-setup complete.
Purpose: Scaffolded project copy-ready as starter template. All base code, utilities, interfaces, infrastructure services created — best-practice setup, generic functions any feature story reuses.
Key distinction: Architecture infrastructure creation, NOT feature implementation — the foundation layer all stories build upon.
Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).
Activation Guards (MANDATORY — Check Before Executing)
ALL conditions must be true to proceed:
Workflow check: Active workflow is workflow-greenfield-init OR workflow-big-feature. If not → SKIP this skill entirely, mark step as completed.
Existing scaffolding check: AI MUST ATTENTION self-investigate for existing base/foundational abstractions:
If existing scaffolding found → SKIP. Log: "Existing scaffolding detected at {file:line}. Skipping $scaffold step." Mark step as completed.
If NO foundational abstractions found → PROCEED with full scaffolding workflow below.
When to Use
After the second $plan + $plan-review in greenfield-init or big-feature workflows
Before $feature-implement begins implementing feature stories
When a new service/module needs its own base architecture within an existing project
NOT when the project already has established base classes and infrastructure
Workflow
Read Plan — Parse the implementation plan for architecture decisions, tech stack, and domain model
Generate Scaffolding Checklist — Produce a checklist of all required base classes and infrastructure from the Backend + Frontend checklists below
Validate Against Plan — Ensure every architecture decision in the plan has corresponding scaffolding items
Present to User — Use ask the user directly to confirm checklist before generating code
Scaffold — Create all base classes, interfaces, abstractions, and infrastructure code
Verify — Compile/build to ensure no syntax errors; validate OOP/SOLID compliance
Backend Scaffolding Categories
AI must self-investigate chosen tech stack, produce a checklist covering these categories. Names below are illustrative — adapt to the project's language, framework conventions, and actual needs.
Domain Layer
Base entity interface + abstract class (Id, timestamps, audit fields)
Value object base (equality by value)
Domain event interface
Application Layer
Command/query handler abstractions (CQRS if applicable)
Validation result pattern
Base DTO with mapping protocol
Pagination wrapper
Operation result pattern (success/failure)
Infrastructure Layer
Generic repository interface + one concrete implementation
Unit of work interface (if applicable)
Messaging/event bus abstraction
External service abstractions (cache, storage, email — only if plan requires them)
Author docs/project-reference/ui-review-principles.md (the project-adopted UI-review PRINCIPLES the later $ui-review gate reads — these are design-time decisions, hand-authored, NOT code-derived). Capture, as project-enforced principles, every UI-review dimension: Overflow & scroll containment (long-content truncation/wrap) · Responsive & small-screen (flex-wrap / row-to-column so it stays usable on small devices) · Flex-vs-fixed sizing (flex-grow vs hard-coded dimensions) · z-index discipline (a documented layering scale, no ad-hoc values) · BEM on all elements · Async states (loading indicator, user-visible error surface, empty state, in-flight disable) · Nesting depth ≤ 3 / no magic numbers. Cross-link to design-system/README.md and scss-styling-guide so the seeded principle doc and the scan-derived docs form one navigable set. Contains NO real endpoints/keys.
No-UI skip rule: author this doc ONLY when a frontend/UI stack is scaffolded. Backend-only project → SKIP and log the reason.
Example / Golden-Path Reference Scaffolding (copy-me implementations — MANDATORY)
MANDATORY when scaffolding a foundation: beyond the empty base abstractions above, emit ONE worked, compile-checked example per best-practice pattern — a copy-me reference implementation per layer. Empty abstractions are unverified skeletons; a worked example built ON TOP turns each base class into demonstrated, reviewable usage. This example set is exactly what Phase-02's $architecture-review-full grades, so it must exist before that gate runs.
Examples live in a DEDICATED, ISOLATED examples/ tree (project-root examples/ or docs/project-reference/examples/) — NEVER mixed into the production src/ tree.
Name every file *.example.* (e.g. create-order.command.example.ts, Order.entity.example.cs).
CI-compiled/linted but EXCLUDED from the production build via a project-appropriate mechanism (separate compile target / tsconfig references / test-only project / build-exclude glob).
Devs COPY an example into src/ to start a real feature; the whole examples/ tree is deleted wholesale once no longer needed.
One worked example per applicable pattern (target ≥ 11)
Frontend (only if a UI stack is present): form component · list component · state store · API service.
Tests: one example integration test exercising the example command/query on BOTH the happy path AND a failure path.
Absent-layer skips: render fewer ONLY when a layer is genuinely absent (e.g. a backend-only project skips the frontend examples) — LOG each skipped example and WHY.
Every example MUST
Follow the project's detected patterns — read docs/project-reference/*-patterns-reference.md and mirror the exact shapes.
USE the scaffolded base abstractions (demonstrate them in action; do NOT re-implement them).
Compile/lint clean under the CI (non-production) target.
Carry this header comment verbatim (adapt the comment syntax to the language): GOLDEN-PATH EXAMPLE — copy into src/ for real features; the examples/ tree is deleted when unused; NOT compiled into the production build.
Contain NO secrets, real credentials, or real endpoints — use obvious placeholders ONLY (EXAMPLE_API_KEY, example.invalid, 00000000-0000-0000-0000-000000000000).
Right-sizing
Examples DEMONSTRATE patterns — NOT a feature. Honor the scale-tier guard: a tiny T0/B0 project gets the minimal applicable set, never speculative extras.
Code Quality Gate Tooling (MANDATORY MUST ATTENTION — Setup Before Any Feature Code)
MANDATORY IMPORTANT MUST ATTENTION scaffold ALL code quality enforcement tools as part of project infrastructure — code that passes without quality gates is technical debt from day one.
Static Analysis & Linting
MANDATORY MUST ATTENTION configure language-appropriate linter with strict ruleset (zero warnings policy on new code)
MANDATORY MUST ATTENTION configure static code analyzer with quality gate thresholds (complexity, duplication) — treat line-coverage as a reported DIAGNOSTIC, NOT a build-failing threshold
MANDATORY MUST ATTENTION enable compiler/transpiler strict mode and treat warnings as errors on build
MANDATORY MUST ATTENTION add code style formatter with shared config (enforce consistent formatting across team)
Build-Time Quality Enforcement
MANDATORY MUST ATTENTION configure pre-commit hooks to run linter + formatter automatically
MANDATORY MUST ATTENTION configure CI pipeline to fail on any linter violation, analyzer warning, or test failure
MANDATORY MUST ATTENTION do NOT gate the build on a line-coverage %; report line-coverage as a diagnostic only (low = useful untested-area signal, high ≠ quality). If a test-strength gate is wanted, gate on mutation score (surviving mutant = missing/weak assertion) with line-coverage as the diagnostic. Keep behavior/change-coverage (each behavior-changing file has a test asserting the changed outcome) as the meaningful coverage notion
MANDATORY MUST ATTENTION enable security vulnerability scanning in dependency management
Code Rules & Standards
MANDATORY MUST ATTENTION create shared linter config file at project root (team-wide consistency)
MANDATORY MUST ATTENTION create shared formatter config file at project root
MANDATORY MUST ATTENTION create .editorconfig for cross-IDE consistency (indentation, encoding, line endings)
MANDATORY MUST ATTENTION document code quality standards in project README or contributing guide
Harness Integration (MANDATORY — Do Not Skip)
MANDATORY MUST ATTENTION delegate ALL computational sensor setup to $linter-setup:
Do NOT manually configure linters, formatters, or pre-commit hooks in this skill
$linter-setup handles: tool research → install → configure → pre-commit hooks → CI gates
$harness-setup handles: full harness inventory (feedforward guides + all feedback types)
WHY: Code quality tooling is part of the project's outer agent harness. A checklist of installs is not a harness — a harness is a system of guides and sensors where each control fires at the right lifecycle stage and produces signals the agent can consume.
$harness-setup — full harness inventory (all feedforward guides + all feedback sensors)
Do NOT proceed to $feature-implement until both complete. ($scaffold verification gate enforces this)
Production Readiness Scaffolding (MANDATORY)
Scaffold Production Readiness — See <!-- SYNC:scaffold-production-readiness --> block above for full inline protocol.
Every scaffolded project MUST ATTENTION include these 5 foundations. AI must detect tech stack from the plan/architecture report, present 2-3 options per concern by asking the user directly.
1. Code Quality Tooling
Handled by $linter-setup skill — do NOT duplicate here.
Verify completion: check that .editorconfig, linter config, and pre-commit hook config files exist.
If missing → block scaffold completion, invoke $linter-setup.
2. Error Handling Foundation
Detect frontend framework → select from protocol's framework patterns
Generate: error types, HTTP interceptor, notification service, global error handler
Minimum 4 files for frontend, 3 for backend-only
Run protocol's verification checklist
3. Loading State Management
Detect frontend framework → select from protocol's framework patterns
Configure retry + circuit breaker + timeout per outbound dependency
Generate integration tests for both the happy path and the failure path
Run protocol's verification checklist
Scaffold Handoff from Architecture-Design
If an architecture report exists (from $architecture-design), read the "Scaffold Handoff — Tool Choices" table and use those selections instead of re-asking the user.
OOP/SOLID Compliance Rules (ENFORCE)
Single Responsibility — Each base class handles ONE concern
Open/Closed — Base classes are extensible via inheritance, closed for modification
Liskov Substitution — Concrete implementations are substitutable for their base
Interface Segregation — Small, focused interfaces (not one giant IService)
Dependency Inversion — All infrastructure behind interfaces, injected via DI
Anti-patterns to prevent:
God classes combining multiple concerns
Concrete dependencies (always depend on abstractions)
Base classes with unused methods that subclasses must override
Missing generic type parameters where applicable
Adaptation Protocol
The checklists above are templates. Before scaffolding:
Read the plan — What tech stack was chosen?
Adapt naming — Match target framework and language conventions
Skip irrelevant items — Not every project needs every item (e.g., skip IFileStorageService if no file uploads)
Add project-specific items — The plan may require additional base classes not in the template
Use ask the user directly — Confirm final checklist with user before generating code
Output
After scaffolding is complete:
Scaffolding Report — List of all created files with brief descriptions
Architecture Diagram — Optional: generate diagram showing the base class hierarchy
Production Readiness Verification — All 5 concern areas verified via protocol checklists
Config Files Generated — Linter, formatter, pre-commit, Docker configs all created
Golden-Path Examples — one worked, compile-checked example per applicable pattern emitted under the isolated, production-excluded examples/ tree; absent-layer skips logged with reason
Verification Gate (MANDATORY before proceeding to $feature-implement)
Run ALL verification checklists from the production readiness protocol:
Code quality tooling verified (Section 1)
Error handling foundation verified (Section 2)
Loading state management verified (Section 3)
Docker development environment verified (Section 4)
$harness-setup completed (harness-inventory.md produced, feedforward guides in place)
Golden-path examples present — one worked example per applicable pattern under an isolated, production-excluded examples/ tree; each compiles/lints under the CI (non-production) target; every example carries the GOLDEN-PATH EXAMPLE header and NO secrets/real endpoints; absent-layer skips logged with reason
BLOCK proceeding to $feature-implement if ANY verification item fails. Fix issues first, then re-verify.
Next Steps
MANDATORY IMPORTANT MUST ATTENTION — NO EXCEPTIONS after completing this skill, MUST ATTENTION use ask the user directly to present these options. Do NOT skip because the task seems "simple" or "obvious" — the user decides:
"$feature-implement (Recommended)" — Begin implementing feature stories on top of the scaffolding
"$workflow-review-changes" — Review scaffolding code before proceeding
"Skip, continue manually" — user decides
[IMPORTANT] Use task tracking to break ALL work into small tasks BEFORE starting — including tasks for each file read. This prevents context loss from long files. For simple tasks, AI MUST ATTENTION ask user whether to skip.
Evidence Gate: MANDATORY IMPORTANT MUST ATTENTION — every claim, finding, and recommendation requires file:line proof or traced evidence with confidence percentage (>80% to act, <80% must verify first).
Nested Task Expansion Contract — For workflow-step invocation, the [Workflow] ... row is only a parent container; the child skill still creates visible phase tasks.
Call the current task list first. If a matching active parent workflow row exists, set nested=true and record parentTaskId; otherwise run standalone.
Create one task per declared phase before phase work. When nested, prefix subjects [N.M] $skill-name — phase.
When nested, link the parent with TaskUpdate(parentTaskId, addBlockedBy: [childIds]).
Orchestrators must pre-expand a child skill's phase list and link the workflow row before invoking that child skill or sub-agent.
Mark exactly one child in_progress before work and completed immediately after evidence is written.
Complete the parent only after all child tasks are completed or explicitly cancelled with reason.
Blocked until: the current task list done, child phases created, parent linked when nested, first child marked in_progress.
Project Reference Docs Gate — Run after task-tracking bootstrap and before target/source file reads, grep, edits, or analysis. Project docs override generic framework assumptions.
Identify scope: file types, domain area, and operation.
Read docs/project-config.json first — the project's machine-readable map. It is the single source of truth for THIS repo (modules/paths, framework + search keywords, test/E2E/integration run-commands, design system, architecture rules, workflow patterns); ground exact paths, run-commands, and conventions on it before investigating, planning, or coding — never assume framework defaults (CLAUDE.md + reference docs are derived from it). If it — or the docs index, lessons.md, CLAUDE.md, AGENTS.md, or any required reference doc — is missing or stale, auto-run $project-init or the narrow route ($project-config, $docs-init, $scan-all, $scan --target=<key>, $claude-md-init) first; if Codex mirrors or AGENTS.md are stale, ask the user to run $sync-codex (never auto-run it).
Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act.
Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.
Understand Code First — HARD-GATE: Do NOT write, plan, or fix until you READ existing code.
Search 3+ similar patterns (grep/glob) — cite file:line evidence
Read existing files in target area — understand structure, base classes, conventions
Run python .claude/scripts/code_graph trace <file> --direction both --json when .code-graph/graph.db exists
Map dependencies via connections or callers_of — know what depends on your target
Write investigation to .ai/workspace/analysis/ for non-trivial tasks (3+ files)
Re-read analysis file before implementing — never work from memory alone. — why: long context drifts from the file; the file is ground truth
NEVER invent new patterns when existing ones work — match exactly or document deviation. — why: divergent patterns fragment the codebase and slow every future reader
Test-strength sensor — gate on mutation score, NOT line coverage. Line coverage is a DIAGNOSTIC only: low coverage is a useful NEGATIVE signal (something is untested); high coverage is NOT evidence of quality (tests can execute lines without asserting intent) — NEVER fail a build on a line-coverage %. The real test-strength metric is mutation score (inject faults into changed code; surviving mutant = a missing/weak assertion = write the killing test); gate the build on it where a mutation tool exists. Add property coverage as a second sensor — each [HARD] §4 rule / §5 invariant guarded by ≥1 property/metamorphic test. The property tests themselves are REQUIRED for invariant-owning behaviors (spec [mode=tests] + integration-test force them, not opt-in); what is optional is only wiring property coverage as an automated CI sensor on top. Keep behavior/change-coverage (does each behavior-changing file have a test that asserts the changed outcome) — that notion is meaningful and stays.
Three harness types:
Maintainability — Complexity, duplication, line-coverage (diagnostic only — never a gate), style. Easiest: rich deterministic tooling.
Behaviour — Functional correctness. Hardest: gate on mutation score + property coverage; line coverage stays a diagnostic.
Keep quality left: pre-commit sensors fire first (cheap), CI sensors fire second, post-review last (expensive).
Research-driven: Never hardcode tool choices. Detect tech stack → research ecosystem → present top 2-3 options → user decides. Enforce strictest defaults; loosen only with explicit approval.
Harnessability signals: Strong typing, explicit module boundaries, opinionated frameworks = easier to harness. Treat these as greenfield architectural choices, not just style preferences.
AI Mistake Prevention — Failure modes to avoid on every task:
Re-read files after context changes. Context compaction, resume, or long-running work can make memory stale; verify current files before acting.
Verify generated content against source evidence. AI hallucinates APIs, names, claims, and document facts. Check the relevant source before documenting or referencing.
Check downstream references before deleting or renaming. Removing an artifact can stale docs, generated mirrors, configs, and callers; map references first.
Trace the full impact chain after edits. Changing a definition can miss derived outputs and consumers. Follow the affected chain before declaring done.
Verify ALL affected outputs, not just the first. One green check is not all green checks; validate every output surface the change can affect.
Assume existing values are intentional — ask WHY before changing OR flagging one as a defect. Before changing or reporting a constant, limit, flag, cutoff, wording, or pattern, read nearby context and history, the CALLER's ordering, and 2+ sibling call sites of the same convention. A doc stating WHAT without WHY is missing rationale, not proof of a missing guard.
Surface ambiguity before acting — don't pick silently. Multiple valid interpretations require an explicit question or stated assumption with risk.
Assert the outcome your system owns, not the intermediate state your infrastructure owns. When verifying async work, assert the final business state — never the delivery/retry bookkeeping held in shared infrastructure that any co-running process can write. Such a check passes when run alone and flakes the moment anything else shares that infrastructure.
Keep shared guidance role-relevant. Universal guidance must help every receiving skill or agent; code-specific obligations belong only in code-specific protocols.
IMPORTANT MUST ATTENTION search 3+ existing patterns and read code BEFORE any modification. Run graph trace when graph.db exists.
MANDATORY IMPORTANT MUST ATTENTION cite file:line evidence for every claim. Confidence >80% to act, <60% = do NOT recommend.
IMPORTANT MUST ATTENTION verify all 5 production-readiness foundations (code quality, error handling, loading state, Docker, integration points) before marking scaffold complete.
MUST ATTENTION apply critical + sequential thinking — every claim needs appropriate traced evidence (file:line for repo/code claims; source URL or artifact section for research, product, content, and docs claims); confidence >80% to act, <60% DO NOT recommend. Anti-hallucination: never present guess as fact, admit uncertainty freely, cross-reference independently, stay skeptical of own confidence.
MUST ATTENTION apply AI mistake prevention — verify generated content against evidence, trace downstream references before deleting or renaming, verify all affected outputs, re-read files after context loss, and surface ambiguity before acting.
MANDATORY Before investigating, planning, or coding, read docs/project-config.json (the project map: modules/paths, run-commands, conventions, architecture/workflow rules) + the required project-reference docs, and cite Reference docs read: ....
MANDATORY If project config, root instruction files, or any required reference doc is missing or stale, auto-run $project-init or the narrow lower-level route before ordinary project-specific work.
MANDATORY Parent workflow rows do not replace child phase tracking; expand phases and link the parent when nested.
MANDATORY Orchestrators pre-expand child skill phases before invocation; use [N.M] $skill-name — phase prefixes and one-in_progress discipline.
Prompt-Enhance Closing Anchors
IMPORTANT MUST ATTENTION follow declared step order for this skill; NEVER skip, reorder, or merge steps without explicit user approval
IMPORTANT MUST ATTENTION for every step/sub-skill call: set in_progress before execution, set completed after execution
IMPORTANT MUST ATTENTION every skipped step MUST include explicit reason; every completed step MUST include concise evidence
IMPORTANT MUST ATTENTION if Task tools unavailable, maintain an equivalent step-by-step plan tracker with synchronized statuses
Project Protocol Overlay — Before executing this skill, resolve any PROJECT overlay rules layered onto it: match this skill's name against the Target column of the project's skill-protocol index (docs/project-reference/skill-protocols-reference.md by default; a referenceDocs entry in docs/project-config.json overrides the path), taking the most specific matching tier ONLY — exact name > glob > *. That precedence orders overlays against EACH OTHER, never against this skill. Read ONLY the matched bodies, resolved as <protocols-dir>/<Name>.md; a row's Body link is display text, never a read path. A matched body that is missing or malformed is REPORTED and skipped — never reconstructed from the index Description. No index, or no match -> proceed with no overlay, silently. Full contract: .claude/skills/project-skill-protocol/references/registry.md.
Overlays are ADDITIVE ONLY: they ADD rules on top of this skill's own protocol and NEVER replace, override, disable, or reinterpret a rule it already states — removing every overlay must return this
…(truncated)
1---2name: scaffold3description: [Architecture] Use when scaffolding reusable OOP/SOLID project foundations before feature implementation.4---56> Codex compatibility note:
7>
8> - Invoke repository skills with `$skill-name` in Codex; this mirrored copy rewrites legacy Claude `/skill-name` references.
9> - Task tracker mandate: BEFORE executing any workflow or skill step, create/update task tracking for all steps and keep it synchronized as progress changes.
10> - User-question prompts mean to ask the user directly in Codex.
11> - Ignore Claude-specific mode-switch instructions when they appear.
12> - Strict execution contract: when a user explicitly invokes a skill, execute that skill protocol as written.
13> - Subagent authorization: when a skill is user-invoked or AI-detected and its protocol requires subagents, that skill activation authorizes use of the required `spawn_agent` subagent(s) for that task.
14> - Do not skip, reorder, or merge protocol steps unless the user explicitly approves the deviation first.
15> - For workflow skills, execute each listed child-skill step explicitly and report step-by-step evidence.
16> - If a required step/tool cannot run in this environment, stop and ask the user before adapting.
1718<!-- CODEX:PROJECT-REFERENCE-LOADING:START -->
1920## Codex Project-Reference Loading (No Hooks)
2122Codex uses static project-reference loading instead of runtime-injected project docs.
23When coding, planning, debugging, testing, or reviewing, open project docs explicitly using this routing.
2425**Always read:**
2627- `docs/project-config.json` (project-specific paths, commands, modules, and workflow/test settings)
28- `docs/project-reference/docs-index-reference.md` (routes to the full `docs/project-reference/*` catalog)
29- `docs/project-reference/lessons.md` (always-on guardrails and anti-patterns)
3031**Missing/stale context route:** If `docs/project-config.json`, the docs index, `lessons.md`, `CLAUDE.md`, `AGENTS.md`, or any task-required reference doc is missing or stale, auto-run `$project-init` or the narrow setup route (`$project-config`, `$docs-init`, `$scan-all`, `$scan --target=<key>`, `$claude-md-init`) before ordinary project-specific work. If Codex mirrors or `AGENTS.md` are missing/stale, ask the user to run `$sync-codex`; do not auto-run it.
3233**Situation-based docs:**
3435- Project structure/architecture/tech-stack/deployment/setup (any layer — backend, frontend, or infra): `project-structure-reference.md`
36- Backend/CQRS/API/domain/entity changes: `backend-patterns-reference.md`, `domain-entities-reference.md`
37- Frontend/UI/styling/design-system: `frontend-patterns-reference.md`, `scss-styling-guide.md`, `design-system/README.md`
38- Spec authoring, `docs/specs/` pathing, or TC format: `feature-spec-reference.md`, `spec-system-reference.md`, `spec-principles.md`
39- Behavior/public-contract changes or spec-test-code sync: `workflow-spec-test-code-cycle-reference.md` plus the spec docs above
40- Derived spec indexes/ERDs/reimplementation guides: `spec-system-reference.md` and source Feature Specs under `docs/specs/`
41- Integration test implementation/review: `integration-test-reference.md`
42- E2E test implementation/review: `e2e-test-reference.md`
43- Code review/audit work: `code-review-rules.md` plus domain docs above based on changed files
4445Do not read all docs blindly. Start from `docs-index-reference.md`, then open only relevant files for the task.
4647<!-- CODEX:PROJECT-REFERENCE-LOADING:END -->
4849<!-- PROMPT-ENHANCE:STEP-TASK-ANCHOR:START -->
5051> **[BLOCKING]** Execute skill steps in declared order. NEVER skip, reorder, or merge steps without explicit user approval.
52> **[BLOCKING]** Before each step or sub-skill call, update task tracking: set `in_progress` when step starts, set `completed` when step ends.
53> **[BLOCKING]** Every completed/skipped step MUST include brief evidence or explicit skip reason.
54> **[BLOCKING]** If Task tools are unavailable, create and maintain an equivalent step-by-step plan tracker with the same status transitions.
5556<!-- PROMPT-ENHANCE:STEP-TASK-ANCHOR:END -->
5758## Quick Summary
5960**Goal:** Generate and validate the project's architecture scaffolding — all base classes, interfaces, infrastructure abstractions, and reusable foundation code — BEFORE any feature story implementation begins, producing a copy-ready, OOP/SOLID-compliant architecture foundation with quality-gate tooling that every feature story reuses before implementation starts.
6162**Summary:**
6364- **Gate-first:** check Activation Guards before any work — proceed ONLY in `workflow-greenfield-init` / `workflow-big-feature` AND when grep finds NO existing base/abstract/infrastructure scaffolding; otherwise SKIP and mark the step completed.
65- **Main steps (do ALL, in order):** (1) Read Plan — parse tech stack, architecture decisions, domain model; (2) Generate Scaffolding Checklist from the Backend + Frontend/UI categories; (3) Validate Against Plan — every architecture decision has a scaffolding item; (4) Present to User by asking the user directly to confirm the checklist; (5) Scaffold — create all base classes, interfaces, abstractions, infra code + the 5 production-readiness foundations; (6) Verify — build/compile + OOP/SOLID compliance + Verification Gate. Then invoke `$linter-setup` → `$harness-setup`, then ask the user directly handoff.
66- **Scope:** architecture-infrastructure creation (base classes, interfaces, DI, repos, cross-cutting), NOT feature implementation — checklists are TEMPLATES: adapt naming to the detected tech stack, skip irrelevant items, add plan-specific ones.
67- **Production-readiness:** stand up all 5 foundations (code-quality tooling, error handling, loading state, Docker, integration points) and delegate ALL sensor setup to `$linter-setup` then `$harness-setup` — never hand-configure linters/hooks here. — why: a checklist of installs is not a harness.
68- **Hard gate:** enforce OOP/SOLID on every base class and HARD-BLOCK the handoff to `$feature-implement` until the Verification Gate passes — all 5 foundations verified plus `$linter-setup` and `$harness-setup` complete.
6970**Purpose:** Scaffolded project copy-ready as starter template. All base code, utilities, interfaces, infrastructure services created — best-practice setup, generic functions any feature story reuses.
7172**Key distinction:** Architecture infrastructure creation, NOT feature implementation — the foundation layer all stories build upon.
7374**Be skeptical. Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence percentages (Idea should be more than 80%).**
7576## Activation Guards (MANDATORY — Check Before Executing)
7778**ALL conditions must be true to proceed:**
79801. **Workflow check:** Active workflow is `workflow-greenfield-init` OR `workflow-big-feature`. If not → SKIP this skill entirely, mark step as completed.
812. **Existing scaffolding check:** AI MUST ATTENTION self-investigate for existing base/foundational abstractions:
82 - Abstract/base classes: grep `abstract class.*Base|Base[A-Z]\w+|Abstract[A-Z]\w+`
83 - Generic interfaces: grep `interface I\w+<|IGeneric|IBase`
84 - Infrastructure abstractions: grep `IRepository|IUnitOfWork|IService|IHandler`
85 - Utility/extension layers: grep `Extensions|Helpers|Utils|Common` (directories or classes)
86 - Frontend foundations: grep `base.*component|base.*service|base.*store|abstract.*component` (case-insensitive)
87 - DI/IoC registration: grep `AddScoped|AddSingleton|providers:|NgModule|@Injectable`
883. **If existing scaffolding found → SKIP.** Log: "Existing scaffolding detected at {file:line}. Skipping $scaffold step." Mark step as completed.
894. **If NO foundational abstractions found → PROCEED** with full scaffolding workflow below.
9091## When to Use
9293- After the second `$plan` + `$plan-review` in greenfield-init or big-feature workflows
94- Before `$feature-implement` begins implementing feature stories
95- When a new service/module needs its own base architecture within an existing project
96- **NOT** when the project already has established base classes and infrastructure
9798## Workflow
991001. **Read Plan** — Parse the implementation plan for architecture decisions, tech stack, and domain model
1012. **Generate Scaffolding Checklist** — Produce a checklist of all required base classes and infrastructure from the Backend + Frontend checklists below
1023. **Validate Against Plan** — Ensure every architecture decision in the plan has corresponding scaffolding items
1034. **Present to User** — Use ask the user directly to confirm checklist before generating code
1045. **Scaffold** — Create all base classes, interfaces, abstractions, and infrastructure code
1056. **Verify** — Compile/build to ensure no syntax errors; validate OOP/SOLID compliance
106107## Backend Scaffolding Categories
108109AI must self-investigate chosen tech stack, produce a checklist covering these categories. Names below are illustrative — adapt to the project's language, framework conventions, and actual needs.
110111### Domain Layer
112113- [ ] Base entity interface + abstract class (Id, timestamps, audit fields)
114- [ ] Value object base (equality by value)
115- [ ] Domain event interface
116117### Application Layer
118119- [ ] Command/query handler abstractions (CQRS if applicable)
120- [ ] Validation result pattern
121- [ ] Base DTO with mapping protocol
122- [ ] Pagination wrapper
123- [ ] Operation result pattern (success/failure)
124125### Infrastructure Layer
126127- [ ] Generic repository interface + one concrete implementation
128- [ ] Unit of work interface (if applicable)
129- [ ] Messaging/event bus abstraction
130- [ ] External service abstractions (cache, storage, email — only if plan requires them)
131- [ ] Database context / connection setup
132- [ ] DI/IoC registration module
133134### Cross-Cutting
135136- [ ] Current user context abstraction
137- [ ] Testable date/time provider
138- [ ] Exception hierarchy (domain, validation, not-found)
139- [ ] Error handling middleware
140- [ ] Strongly-typed configuration models
141142## Frontend Scaffolding Categories
143144### Core Architecture
145146- [ ] Base component with lifecycle/destroy cleanup
147- [ ] Base form component with validation, dirty tracking
148- [ ] Base list component with pagination, sorting, filtering
149150### State & API
151152- [ ] Base state store with loading/error/data pattern
153- [ ] Base API service with interceptors, error handling
154- [ ] Auth interceptor + environment config
155156### Shared Utilities
157158- [ ] Base model with serialization helpers
159- [ ] Common utility functions (date, validation, formatting)
160161### UI Foundation
162163> **Skip if:** Backend-only project, no frontend component. **Apply if:** Project has ANY frontend.
164165#### Design Token Files
166167- [ ] Create design token file(s) per chosen format (CSS custom properties / SCSS variables / JSON)
168- [ ] Define minimum token set: colors (primary, secondary, surface, bg, text, error, success, warning), spacing (xs-xl), typography (heading/body/caption families + sizes), breakpoints, shadows, z-index
169- [ ] Create theme file(s) if theming required (light/dark CSS classes or theme provider)
170171#### Base Layout & Responsive
172173- [ ] Base layout component (app shell: header, sidebar/nav, main content, footer)
174- [ ] Responsive container/grid utility
175- [ ] Responsive mixin/utility for breakpoints
176- [ ] Mobile-first media query definitions
177178#### Base UI Components
179180- [ ] Loading indicator component (spinner or skeleton)
181- [ ] Error display component (inline + page-level)
182- [ ] Empty state component (message + action)
183- [ ] Notification/toast component
184- [ ] Base button component with variants (primary, secondary, ghost, danger)
185- [ ] Base input component with validation display
186187#### Design System Documentation
188189- [ ] Create `docs/project-reference/design-system/README.md` skeleton with: token naming conventions, component tier classification (Common/Domain-Shared/Page), usage examples
190- [ ] **Author `docs/project-reference/ui-review-principles.md`** (the project-adopted UI-review PRINCIPLES the later `$ui-review` gate reads — these are design-time decisions, hand-authored, NOT code-derived). Capture, as project-enforced principles, every UI-review dimension: **Overflow & scroll containment** (long-content truncation/wrap) · **Responsive & small-screen** (flex-wrap / row-to-column so it stays usable on small devices) · **Flex-vs-fixed sizing** (flex-grow vs hard-coded dimensions) · **z-index discipline** (a documented layering scale, no ad-hoc values) · **BEM on all elements** · **Async states** (loading indicator, user-visible error surface, empty state, in-flight disable) · **Nesting depth ≤ 3 / no magic numbers**. **Cross-link** to `design-system/README.md` and `scss-styling-guide` so the seeded principle doc and the scan-derived docs form one navigable set. Contains NO real endpoints/keys.
191 - **No-UI skip rule:** author this doc ONLY when a frontend/UI stack is scaffolded. Backend-only project → SKIP and log the reason.
192193## Example / Golden-Path Reference Scaffolding (copy-me implementations — MANDATORY)
194195> **MANDATORY when scaffolding a foundation:** beyond the empty base abstractions above, emit **ONE worked, compile-checked example per best-practice pattern** — a copy-me reference implementation per layer. Empty abstractions are unverified skeletons; a worked example built ON TOP turns each base class into demonstrated, reviewable usage. This example set is exactly what Phase-02's `$architecture-review-full` grades, so it must exist before that gate runs.
196197### Location & lifecycle (isolated, production-excluded)
198199- Examples live in a DEDICATED, ISOLATED `examples/` tree (project-root `examples/` or `docs/project-reference/examples/`) — **NEVER mixed into the production `src/` tree.**
200- Name every file `*.example.*` (e.g. `create-order.command.example.ts`, `Order.entity.example.cs`).
201- **CI-compiled/linted but EXCLUDED from the production build** via a project-appropriate mechanism (separate compile target / tsconfig references / test-only project / build-exclude glob).
202- Devs COPY an example into `src/` to start a real feature; the whole `examples/` tree is deleted wholesale once no longer needed.
203204### One worked example per applicable pattern (target ≥ 11)
205206- **Backend:** command · query · command/query handler · entity-with-invariants · value-object · repository (concrete impl) · domain event + event handler.
207- **Frontend (only if a UI stack is present):** form component · list component · state store · API service.
208- **Tests:** one example integration test exercising the example command/query on BOTH the happy path AND a failure path.
209- **Absent-layer skips:** render fewer ONLY when a layer is genuinely absent (e.g. a backend-only project skips the frontend examples) — LOG each skipped example and WHY.
210211### Every example MUST
2122131. Follow the project's detected patterns — read `docs/project-reference/*-patterns-reference.md` and mirror the exact shapes.
2142. USE the scaffolded base abstractions (demonstrate them in action; do NOT re-implement them).
2153. Compile/lint clean under the CI (non-production) target.
2164. Carry this header comment verbatim (adapt the comment syntax to the language): `GOLDEN-PATH EXAMPLE — copy into src/ for real features; the examples/ tree is deleted when unused; NOT compiled into the production build.`
2175. Contain **NO secrets, real credentials, or real endpoints** — use obvious placeholders ONLY (`EXAMPLE_API_KEY`, `example.invalid`, `00000000-0000-0000-0000-000000000000`).
218219### Right-sizing
220221Examples DEMONSTRATE patterns — NOT a feature. Honor the scale-tier guard: a tiny T0/B0 project gets the minimal applicable set, never speculative extras.
222223## Code Quality Gate Tooling (MANDATORY MUST ATTENTION — Setup Before Any Feature Code)
224225**MANDATORY IMPORTANT MUST ATTENTION** scaffold ALL code quality enforcement tools as part of project infrastructure — code that passes without quality gates is technical debt from day one.
226227### Static Analysis & Linting
228229- [ ] **MANDATORY MUST ATTENTION** configure language-appropriate linter with strict ruleset (zero warnings policy on new code)
230- [ ] **MANDATORY MUST ATTENTION** configure static code analyzer with quality gate thresholds (complexity, duplication) — treat line-coverage as a reported DIAGNOSTIC, NOT a build-failing threshold
231- [ ] **MANDATORY MUST ATTENTION** enable compiler/transpiler strict mode and treat warnings as errors on build
232- [ ] **MANDATORY MUST ATTENTION** add code style formatter with shared config (enforce consistent formatting across team)
233234### Build-Time Quality Enforcement
235236- [ ] **MANDATORY MUST ATTENTION** configure pre-commit hooks to run linter + formatter automatically
237- [ ] **MANDATORY MUST ATTENTION** configure CI pipeline to fail on any linter violation, analyzer warning, or test failure
238- [ ] **MANDATORY MUST ATTENTION** do NOT gate the build on a line-coverage %; report line-coverage as a diagnostic only (low = useful untested-area signal, high ≠ quality). If a test-strength gate is wanted, gate on mutation score (surviving mutant = missing/weak assertion) with line-coverage as the diagnostic. Keep behavior/change-coverage (each behavior-changing file has a test asserting the changed outcome) as the meaningful coverage notion
239- [ ] **MANDATORY MUST ATTENTION** enable security vulnerability scanning in dependency management
240241### Code Rules & Standards
242243- [ ] **MANDATORY MUST ATTENTION** create shared linter config file at project root (team-wide consistency)
244- [ ] **MANDATORY MUST ATTENTION** create shared formatter config file at project root
245- [ ] **MANDATORY MUST ATTENTION** create `.editorconfig` for cross-IDE consistency (indentation, encoding, line endings)
246- [ ] **MANDATORY MUST ATTENTION** document code quality standards in project README or contributing guide
247248### Harness Integration (MANDATORY — Do Not Skip)
249250**MANDATORY MUST ATTENTION** delegate ALL computational sensor setup to `$linter-setup`:
251252- Do NOT manually configure linters, formatters, or pre-commit hooks in this skill
253- `$linter-setup` handles: tool research → install → configure → pre-commit hooks → CI gates
254- `$harness-setup` handles: full harness inventory (feedforward guides + all feedback types)
255256**WHY:** Code quality tooling is part of the project's outer agent harness. A checklist of installs is not a harness — a harness is a system of guides and sensors where each control fires at the right lifecycle stage and produces signals the agent can consume.
257258**After scaffold, invoke (in order):**
2592601. `$linter-setup` — computational feedback sensors (deterministic, fast, always-on)
2612. `$harness-setup` — full harness inventory (all feedforward guides + all feedback sensors)
262263**Do NOT proceed to `$feature-implement` until both complete.** (`$scaffold` verification gate enforces this)
264265## Production Readiness Scaffolding (MANDATORY)
266267> **Scaffold Production Readiness** — See `<!-- SYNC:scaffold-production-readiness -->` block above for full inline protocol.
268269Every scaffolded project MUST ATTENTION include these 5 foundations. AI must detect tech stack from the plan/architecture report, present 2-3 options per concern by asking the user directly.
270271### 1. Code Quality Tooling
272273Handled by `$linter-setup` skill — do NOT duplicate here.
274Verify completion: check that `.editorconfig`, linter config, and pre-commit hook config files exist.
275If missing → block scaffold completion, invoke `$linter-setup`.
276277### 2. Error Handling Foundation
278279- Detect frontend framework → select from protocol's framework patterns
280- Generate: error types, HTTP interceptor, notification service, global error handler
281- Minimum 4 files for frontend, 3 for backend-only
282- Run protocol's verification checklist
283284### 3. Loading State Management
285286- Detect frontend framework → select from protocol's framework patterns
287- Generate: loading service, HTTP loading interceptor, loading indicator component
288- Counter-based tracking, 300ms display delay, skip token mechanism
289- Run protocol's verification checklist
290291### 4. Docker Development Environment
292293- Always scaffold (unless user explicitly opts out)
294- Generate: docker-compose.yml (with profiles), Dockerfile (multi-stage), .dockerignore, .env.example
295- Use 127.0.0.1 binding, health checks on all services, non-root user in prod
296- Run protocol's verification checklist
297298### 5. Integration Points
299300- Document each outbound boundary (downstream service, queue, third-party API, shared DB)
301- Configure retry + circuit breaker + timeout per outbound dependency
302- Generate integration tests for both the happy path and the failure path
303- Run protocol's verification checklist
304305### Scaffold Handoff from Architecture-Design
306307If an architecture report exists (from `$architecture-design`), read the "Scaffold Handoff — Tool Choices" table and use those selections instead of re-asking the user.
308309## OOP/SOLID Compliance Rules (ENFORCE)
3103111. **Single Responsibility** — Each base class handles ONE concern
3122. **Open/Closed** — Base classes are extensible via inheritance, closed for modification
3133. **Liskov Substitution** — Concrete implementations are substitutable for their base
3144. **Interface Segregation** — Small, focused interfaces (not one giant IService)
3155. **Dependency Inversion** — All infrastructure behind interfaces, injected via DI
316317**Anti-patterns to prevent:**
318319- God classes combining multiple concerns
320- Concrete dependencies (always depend on abstractions)
321- Base classes with unused methods that subclasses must override
322- Missing generic type parameters where applicable
323324## Adaptation Protocol
325326The checklists above are **templates**. Before scaffolding:
3273281. **Read the plan** — What tech stack was chosen?
3292. **Adapt naming** — Match target framework and language conventions
3303. **Skip irrelevant items** — Not every project needs every item (e.g., skip IFileStorageService if no file uploads)
3314. **Add project-specific items** — The plan may require additional base classes not in the template
3325. **Use ask the user directly** — Confirm final checklist with user before generating code
333334## Output
335336After scaffolding is complete:
3373381. **Scaffolding Report** — List of all created files with brief descriptions
3392. **Build Verification** — Compilation/type-check passes
3403. **Architecture Diagram** — Optional: generate diagram showing the base class hierarchy
3414. **Production Readiness Verification** — All 5 concern areas verified via protocol checklists
3425. **Config Files Generated** — Linter, formatter, pre-commit, Docker configs all created
3436. **Golden-Path Examples** — one worked, compile-checked example per applicable pattern emitted under the isolated, production-excluded `examples/` tree; absent-layer skips logged with reason
344345## Verification Gate (MANDATORY before proceeding to $feature-implement)
346347Run ALL verification checklists from the production readiness protocol:
348349- [ ] Code quality tooling verified (Section 1)
350- [ ] Error handling foundation verified (Section 2)
351- [ ] Loading state management verified (Section 3)
352- [ ] Docker development environment verified (Section 4)
353- [ ] Integration points verified (Section 5)
354- [ ] `$linter-setup` completed (linter + formatter + pre-commit + CI gate configured)
355- [ ] `$harness-setup` completed (harness-inventory.md produced, feedforward guides in place)
356- [ ] Golden-path examples present — one worked example per applicable pattern under an isolated, production-excluded `examples/` tree; each compiles/lints under the CI (non-production) target; every example carries the `GOLDEN-PATH EXAMPLE` header and NO secrets/real endpoints; absent-layer skips logged with reason
357358**BLOCK proceeding to `$feature-implement` if ANY verification item fails.** Fix issues first, then re-verify.
359360## Next Steps
361362**MANDATORY IMPORTANT MUST ATTENTION — NO EXCEPTIONS** after completing this skill, MUST ATTENTION use ask the user directly to present these options. Do NOT skip because the task seems "simple" or "obvious" — the user decides:
363364- **"$feature-implement (Recommended)"** — Begin implementing feature stories on top of the scaffolding
365- **"$workflow-review-changes"** — Review scaffolding code before proceeding
366- **"Skip, continue manually"** — user decides
367368> **[IMPORTANT]** Use task tracking to break ALL work into small tasks BEFORE starting — including tasks for each file read. This prevents context loss from long files. For simple tasks, AI MUST ATTENTION ask user whether to skip.
369370> **Evidence Gate:** MANDATORY IMPORTANT MUST ATTENTION — every claim, finding, and recommendation requires `file:line` proof or traced evidence with confidence percentage (>80% to act, <80% must verify first).
371372<!-- SYNC:nested-task-creation -->
373374> **Nested Task Expansion Contract** — For workflow-step invocation, the `[Workflow] ...` row is only a parent container; the child skill still creates visible phase tasks.
375>
376> 1. Call the current task list first. If a matching active parent workflow row exists, set `nested=true` and record `parentTaskId`; otherwise run standalone.
377> 2. Create one task per declared phase before phase work. When nested, prefix subjects `[N.M] $skill-name — phase`.
378> 3. When nested, link the parent with `TaskUpdate(parentTaskId, addBlockedBy: [childIds])`.
379> 4. Orchestrators must pre-expand a child skill's phase list and link the workflow row before invoking that child skill or sub-agent.
380> 5. Mark exactly one child `in_progress` before work and `completed` immediately after evidence is written.
381> 6. Complete the parent only after all child tasks are completed or explicitly cancelled with reason.
382>
383> **Blocked until:** the current task list done, child phases created, parent linked when nested, first child marked `in_progress`.
384385<!-- /SYNC:nested-task-creation -->
386387<!-- SYNC:project-reference-docs-guide -->
388389> **Project Reference Docs Gate** — Run after task-tracking bootstrap and before target/source file reads, grep, edits, or analysis. Project docs override generic framework assumptions.
390>
391> 1. Identify scope: file types, domain area, and operation.
392> 2. **Read `docs/project-config.json` first — the project's machine-readable map.** It is the single source of truth for THIS repo (modules/paths, framework + search keywords, test/E2E/integration run-commands, design system, architecture rules, workflow patterns); ground exact paths, run-commands, and conventions on it **before investigating, planning, or coding** — never assume framework defaults (`CLAUDE.md` + reference docs are derived from it). If it — or the docs index, `lessons.md`, `CLAUDE.md`, `AGENTS.md`, or any required reference doc — is missing or stale, auto-run `$project-init` or the narrow route (`$project-config`, `$docs-init`, `$scan-all`, `$scan --target=<key>`, `$claude-md-init`) first; if Codex mirrors or `AGENTS.md` are stale, ask the user to run `$sync-codex` (never auto-run it).
393> 3. Required docs by trigger: always `docs/project-reference/lessons.md`; doc lookup `docs-index-reference.md`; review `code-review-rules.md`; backend/CQRS/API `backend-patterns-reference.md`; domain/entity `domain-entities-reference.md`; frontend/UI `frontend-patterns-reference.md`; styles/design `scss-styling-guide.md` + `design-system/design-system-canonical.md`; integration tests `integration-test-reference.md`; E2E `e2e-test-reference.md`; feature docs/specs `feature-spec-reference.md` + `spec-system-reference.md` + `spec-principles.md`; behavior/public-contract/spec-test-code sync `workflow-spec-test-code-cycle-reference.md`; derived spec index/ERD/reimplementation guides `spec-system-reference.md` + source Feature Specs under `docs/specs/`; architecture/new area `project-structure-reference.md`.
394> 4. Read every required doc, then before target work state: `Reference docs read: ... | Not applicable: ...`.
395>
396> **Ready when:** scope evaluated, `docs/project-config.json` consulted, required docs checked/read or setup route completed, `lessons.md` confirmed, citation emitted.
397398<!-- /SYNC:project-reference-docs-guide -->
399400<!-- SYNC:critical-thinking-mindset -->
401402> **Critical Thinking Mindset** — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act.
403> **Anti-hallucination:** Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.
404405<!-- /SYNC:critical-thinking-mindset -->
406407<!-- SYNC:understand-code-first -->
408409> **Understand Code First** — HARD-GATE: Do NOT write, plan, or fix until you READ existing code.
410>
411> 1. Search 3+ similar patterns (`grep`/`glob`) — cite `file:line` evidence
412> 2. Read existing files in target area — understand structure, base classes, conventions
413> 3. Run `python .claude/scripts/code_graph trace <file> --direction both --json` when `.code-graph/graph.db` exists
414> 4. Map dependencies via `connections` or `callers_of` — know what depends on your target
415> 5. Write investigation to `.ai/workspace/analysis/` for non-trivial tasks (3+ files)
416> 6. Re-read analysis file before implementing — never work from memory alone. — why: long context drifts from the file; the file is ground truth
417> 7. NEVER invent new patterns when existing ones work — match exactly or document deviation. — why: divergent patterns fragment the codebase and slow every future reader
418>
419> **BLOCKED until:** `- [ ]` Read target files `- [ ]` Grep 3+ patterns `- [ ]` Graph trace (if graph.db exists) `- [ ]` Assumptions verified with evidence
420421<!-- /SYNC:understand-code-first -->
422423<!-- SYNC:scaffold-production-readiness -->
424425> **Scaffold Production Readiness** — Every scaffolded project MUST ATTENTION include 5 foundations:
426>
427> 1. **Code Quality Tooling** — linting, formatting, pre-commit hooks, CI gates. Specific tool choices → `docs/project-reference/` or `project-config.json`.
428> 2. **Error Handling Foundation** — HTTP interceptor, error classification (4xx/5xx taxonomy), user notification, global uncaught handler.
429> 3. **Loading State Management** — counter-based tracker (not boolean toggle), skip-token for background requests, 300ms flicker guard.
430> 4. **Docker Development Environment** — compose profiles (`dev`/`test`/`infra`), multi-stage Dockerfile, health checks on all services, non-root production user.
431> 5. **Integration Points** — document each outbound boundary; configure retry + circuit breaker + timeout; integration tests for happy path and failure path.
432>
433> **BLOCK `$feature-implement` if any foundation is unchecked.** Present 2-3 options per concern by asking the user directly before implementing.
434435<!-- /SYNC:scaffold-production-readiness -->
436437<!-- SYNC:harness-setup -->
438439> **Harness Engineering** — An outer agent harness has two jobs: raise first-attempt quality + provide self-correction feedback loops before human review.
440>
441> **Controls split:**
442>
443> | Axis | Type | Examples | Frequency |
444> | ----------- | ------------- | -------------------------------------------------------------------------------------------------- | ---------------- |
445> | Feedforward | Computational | `.editorconfig`, strict compiler flags, enforced module boundaries | Always-on |
446> | Feedforward | Inferential | `CLAUDE.md` conventions, skill prompts, architecture notes, pattern catalogs | Always-on |
447> | Feedback | Computational | Linters, type checks, pre-commit hooks, ArchUnit/arch-fitness tests, mutation-score gate, CI gates | Pre-commit → CI |
448> | Feedback | Inferential | `$code-review` skill, `$production-readiness-review`, `$security-review`, LLM-as-judge passes | Post-commit → CI |
449>
450> **Test-strength sensor — gate on mutation score, NOT line coverage.** Line coverage is a DIAGNOSTIC only: low coverage is a useful NEGATIVE signal (something is untested); high coverage is NOT evidence of quality (tests can execute lines without asserting intent) — NEVER fail a build on a line-coverage %. The real test-strength metric is **mutation score** (inject faults into changed code; surviving mutant = a missing/weak assertion = write the killing test); gate the build on it where a mutation tool exists. Add **property coverage** as a second sensor — each [HARD] §4 rule / §5 invariant guarded by ≥1 property/metamorphic test. The property tests themselves are REQUIRED for invariant-owning behaviors (`spec [mode=tests]` + `integration-test` force them, not opt-in); what is optional is only wiring property coverage as an _automated CI sensor_ on top. Keep **behavior/change-coverage** (does each behavior-changing file have a test that asserts the changed outcome) — that notion is meaningful and stays.
451>
452> **Three harness types:**
453>
454> 1. **Maintainability** — Complexity, duplication, line-coverage (diagnostic only — never a gate), style. Easiest: rich deterministic tooling.
455> 2. **Architecture fitness** — Module boundaries, dependency direction, performance budgets, observability conventions.
456> 3. **Behaviour** — Functional correctness. Hardest: gate on mutation score + property coverage; line coverage stays a diagnostic.
457>
458> **Keep quality left:** pre-commit sensors fire first (cheap), CI sensors fire second, post-review last (expensive).
459>
460> **Research-driven:** Never hardcode tool choices. Detect tech stack → research ecosystem → present top 2-3 options → user decides. Enforce strictest defaults; loosen only with explicit approval.
461>
462> **Harnessability signals:** Strong typing, explicit module boundaries, opinionated frameworks = easier to harness. Treat these as greenfield architectural choices, not just style preferences.
463464<!-- /SYNC:harness-setup -->
465466<!-- SYNC:ai-mistake-prevention -->
467468> **AI Mistake Prevention** — Failure modes to avoid on every task:
469>
470> **Re-read files after context changes.** Context compaction, resume, or long-running work can make memory stale; verify current files before acting.
471> **Verify generated content against source evidence.** AI hallucinates APIs, names, claims, and document facts. Check the relevant source before documenting or referencing.
472> **Check downstream references before deleting or renaming.** Removing an artifact can stale docs, generated mirrors, configs, and callers; map references first.
473> **Trace the full impact chain after edits.** Changing a definition can miss derived outputs and consumers. Follow the affected chain before declaring done.
474> **Verify ALL affected outputs, not just the first.** One green check is not all green checks; validate every output surface the change can affect.
475> **Assume existing values are intentional — ask WHY before changing OR flagging one as a defect.** Before changing or reporting a constant, limit, flag, cutoff, wording, or pattern, read nearby context and history, the CALLER's ordering, and 2+ sibling call sites of the same convention. A doc stating WHAT without WHY is missing rationale, not proof of a missing guard.
476> **Surface ambiguity before acting — don't pick silently.** Multiple valid interpretations require an explicit question or stated assumption with risk.
477> **Assert the outcome your system owns, not the intermediate state your infrastructure owns.** When verifying async work, assert the final business state — never the delivery/retry bookkeeping held in shared infrastructure that any co-running process can write. Such a check passes when run alone and flakes the moment anything else shares that infrastructure.
478> **Keep shared guidance role-relevant.** Universal guidance must help every receiving skill or agent; code-specific obligations belong only in code-specific protocols.
479480<!-- /SYNC:ai-mistake-prevention -->
481482<!-- SYNC:understand-code-first:reminder -->
483484**IMPORTANT MUST ATTENTION** search 3+ existing patterns and read code BEFORE any modification. Run graph trace when graph.db exists.
485486<!-- /SYNC:understand-code-first:reminder -->
487488<!-- SYNC:evidence-based-reasoning:reminder -->
489490- **MANDATORY IMPORTANT MUST ATTENTION** cite `file:line` evidence for every claim. Confidence >80% to act, <60% = do NOT recommend.
491 <!-- /SYNC:evidence-based-reasoning:reminder -->
492493<!-- SYNC:scaffold-production-readiness:reminder -->
494495**IMPORTANT MUST ATTENTION** verify all 5 production-readiness foundations (code quality, error handling, loading state, Docker, integration points) before marking scaffold complete.
496497<!-- /SYNC:scaffold-production-readiness:reminder -->
498499<!-- SYNC:critical-thinking-mindset:reminder -->
500501**MUST ATTENTION** apply critical + sequential thinking — every claim needs appropriate traced evidence (`file:line` for repo/code claims; source URL or artifact section for research, product, content, and docs claims); confidence >80% to act, <60% DO NOT recommend. Anti-hallucination: never present guess as fact, admit uncertainty freely, cross-reference independently, stay skeptical of own confidence.
502503<!-- /SYNC:critical-thinking-mindset:reminder -->
504505<!-- SYNC:ai-mistake-prevention:reminder -->
506507**MUST ATTENTION** apply AI mistake prevention — verify generated content against evidence, trace downstream references before deleting or renaming, verify all affected outputs, re-read files after context loss, and surface ambiguity before acting.
508509<!-- /SYNC:ai-mistake-prevention:reminder -->
510511<!-- SYNC:project-reference-docs-guide:reminder -->
512513- **MANDATORY** Before investigating, planning, or coding, read `docs/project-config.json` (the project map: modules/paths, run-commands, conventions, architecture/workflow rules) + the required project-reference docs, and cite `Reference docs read: ...`.
514- **MANDATORY** Always include `lessons.md`; project config + conventions override generic framework defaults.
515- **MANDATORY** If project config, root instruction files, or any required reference doc is missing or stale, auto-run `$project-init` or the narrow lower-level route before ordinary project-specific work.
516517<!-- /SYNC:project-reference-docs-guide:reminder -->
518519<!-- SYNC:nested-task-creation:reminder -->
520521- **MANDATORY** Parent workflow rows do not replace child phase tracking; expand phases and link the parent when nested.
522- **MANDATORY** Orchestrators pre-expand child skill phases before invocation; use `[N.M] $skill-name — phase` prefixes and one-`in_progress` discipline.
523524<!-- /SYNC:nested-task-creation:reminder -->
525526<!-- PROMPT-ENHANCE:STEP-TASK-CLOSING:START -->
527528## Prompt-Enhance Closing Anchors
529530**IMPORTANT MUST ATTENTION** follow declared step order for this skill; NEVER skip, reorder, or merge steps without explicit user approval
531**IMPORTANT MUST ATTENTION** for every step/sub-skill call: set `in_progress` before execution, set `completed` after execution
532**IMPORTANT MUST ATTENTION** every skipped step MUST include explicit reason; every completed step MUST include concise evidence
533**IMPORTANT MUST ATTENTION** if Task tools unavailable, maintain an equivalent step-by-step plan tracker with synchronized statuses
534535<!-- PROMPT-ENHANCE:STEP-TASK-CLOSING:END -->
536537<!-- SYNC:project-protocol-overlay -->
538539> **Project Protocol Overlay** — Before executing this skill, resolve any PROJECT overlay rules layered onto it: match this skill's name against the `Target` column of the project's skill-protocol index (`docs/project-reference/skill-protocols-reference.md` by default; a `referenceDocs` entry in `docs/project-config.json` overrides the path), taking the most specific matching tier ONLY — exact name > glob > `*`. **That precedence orders overlays against EACH OTHER, never against this skill.** Read ONLY the matched bodies, resolved as `<protocols-dir>/<Name>.md`; a row's Body link is display text, never a read path. A matched body that is missing or malformed is REPORTED and skipped — never reconstructed from the index Description. No index, or no match -> proceed with no overlay, silently. Full contract: `.claude/skills/project-skill-protocol/references/registry.md`.
540>
541> Overlays are **ADDITIVE ONLY**: they ADD rules on top of this skill's own protocol and NEVER replace, override, disable, or reinterpret a rule it already states — removing every overlay must return this
542543…(truncated)
Run npx skillmds@latest add duc01226/scaffold in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
[Architecture] Use when scaffolding reusable OOP/SOLID project foundations before feature implementation. It is listed under Coding & Dev Tools on SkillMD.
This skill has not completed SkillMD's automated safety review yet. Capability flags: reads secrets. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.
duc01226 (@duc01226) published this skill. Their other Agent Skills are listed on their SkillMD profile.
duc01226