Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
[Architecture] Use when scaffolding reusable OOP/SOLID project foundations before feature implementation.
[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 skill: 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.
Scope is architecture-infrastructure creation (base classes, interfaces, DI, repos, cross-cutting), NOT feature implementation — read the plan, adapt the Backend/Frontend/UI checklists to the detected tech stack, and confirm the final checklist via AskUserQuestion before generating code.
Stand up the production-readiness 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.
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 AskUserQuestion 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 the chosen tech stack and produce a checklist covering these categories. Names below are illustrative — adapt to match 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)
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 the tech stack from the plan/architecture report and present 2-3 options per concern via AskUserQuestion.
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 AskUserQuestion — Confirm final checklist with user before generating code
Output
After scaffolding is complete:
Scaffolding Report — List of all created files with brief descriptions
/harness-setup completed (harness-inventory.md produced, feedforward guides in place)
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, you MUST ATTENTION use AskUserQuestion 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 TaskCreate 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 TaskList 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:TaskList 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 every required doc. 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 lower-level 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.
Before target work, state: Reference docs read: ... | Not applicable: ....
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.
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. Before changing a constant, limit, flag, wording, or pattern, read nearby context and history.
Surface ambiguity before acting — don't pick silently. Multiple valid interpretations require an explicit question or stated assumption with risk.
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 After task-tracking bootstrap and before target/source work, read required project-reference docs and cite Reference docs read: ....
MANDATORY Always include lessons.md; project conventions override generic defaults.
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
Closing Reminders
IMPORTANT MUST ATTENTION Goal: Produce a copy-ready, OOP/SOLID-compliant architecture foundation — base classes, infrastructure abstractions, and quality-gate tooling — that every feature story reuses before implementation starts.
MUST ATTENTION — Protocols in force (concise digest of the SYNC/shared blocks this skill carries):
Nested Task Creation: Expand child phases; link parent when nested.
Critical Thinking Mindset: Traced proof per claim; confidence >80% to act.
Understand Code First: Grep 3+ patterns, read code before modifying.
Scaffold Production Readiness: Verify 5 foundations before scaffold complete.
Harness Setup: Gate on mutation score; NEVER gate on line coverage.
AI Mistake Prevention: verify generated content against evidence, trace downstream references, verify all affected outputs, re-read after context loss, surface ambiguity.
MANDATORY IMPORTANT MUST ATTENTION check Activation Guards FIRST — proceed ONLY in workflow-greenfield-init/workflow-big-feature AND when grep finds NO existing base/abstract/infrastructure scaffolding; otherwise SKIP and mark step completed — why: re-scaffolding an established project duplicates foundations and corrupts existing abstractions.
MANDATORY IMPORTANT MUST ATTENTION grep 3+ existing base/abstract/infra patterns (abstract class.*Base, interface I\w+<, IRepository, base.*component, DI registration) and cite file:line BEFORE generating any scaffolding — existing scaffolding found = SKIP — why: scaffolding over real foundations is the failure the Activation Guards exist to prevent.
MANDATORY IMPORTANT MUST ATTENTION BLOCK /feature-implement until the Verification Gate passes — all 5 production-readiness foundations verified AND both /linter-setup and /harness-setup complete — why: code shipped without quality gates is technical debt from day one.
MANDATORY IMPORTANT MUST ATTENTION delegate ALL sensor setup to /linter-setup then /harness-setup — NEVER hand-configure linters/formatters/pre-commit hooks in this skill — why: a checklist of installs is not a harness; the harness skills wire each control to its lifecycle stage.
MANDATORY IMPORTANT MUST ATTENTION enforce OOP/SOLID on EVERY base class (SRP per concern, depend on abstractions, small focused interfaces, no unused methods subclasses must override) — why: a god/concrete base class propagates its design flaw into every feature story that inherits it.
MANDATORY IMPORTANT MUST ATTENTION the checklists are TEMPLATES — self-investigate the chosen tech stack, adapt naming to framework conventions, skip irrelevant items, and confirm the final checklist via AskUserQuestion before generating code — NEVER auto-decide scope — why: scaffolding the wrong stack's idioms forces a costly rewrite before any feature lands.
MANDATORY IMPORTANT MUST ATTENTION evaluate fit before copying a nearby pattern — closest example ≠ matching preconditions; verify the new context shares the same base classes, scope, and lifetime — why: a foundation lifted from a mismatched context fails silently.
MANDATORY IMPORTANT MUST ATTENTION gate the build on mutation score, NOT a line-coverage % — line coverage is a DIAGNOSTIC only (low = useful untested signal, high ≠ quality) — why: tests can execute lines without asserting intent, so a coverage gate rewards hollow tests.
MANDATORY IMPORTANT MUST ATTENTION cite proof + confidence % for EVERY claim (>80% to act, <60% DO NOT recommend) — NEVER present a guess as fact — why: speculation without evidence is the root of hallucinated foundations.
break work into small todo tasks using BEFORE starting, mark one , mark immediately after evidence lands, and add a final review todo — why: external task state survives context compaction; memory does not.
after scaffold, present vs vs skip via — the user decides; do NOT skip because it "seems obvious" — why: the user owns the handoff decision.
Anti-Rationalization (Closing — reject these excuses):
Excuse the model tells itself
Reality
"It's a new feature, just scaffold it"
Check Activation Guards first — wrong workflow OR existing scaffolding = SKIP and mark completed.
"Already searched for base classes"
Show file:line grep evidence for all 6 guard patterns. No proof = no search.
"I'll just configure the linter inline, it's quick"
NEVER hand-configure sensors — delegate to /linter-setup then /harness-setup. Installs ≠ harness.
"Coverage is high, the foundation is well-tested"
Line coverage is a diagnostic, not a gate. Gate on mutation score; high coverage ≠ asserted intent.
"The stack is obvious, skip the AskUserQuestion"
Checklists are templates — confirm the adapted final checklist with the user before generating code.
"Found a nearby base class, just copy it"
Evaluate fit first — same base classes/scope/lifetime? Closest ≠ matching. Verify before reusing.
"Scaffold's done, jump straight to /feature-implement"
BLOCKED until the Verification Gate passes — all 5 foundations + /linter-setup + /harness-setup.
IMPORTANT MUST ATTENTION check Activation Guards FIRST (SKIP if existing scaffolding or wrong workflow) · BLOCK /feature-implement until the Verification Gate passes · cite file:line + confidence >80% for every claim.
[TASK-PLANNING] Before acting, analyze task scope and systematically break it into small todo tasks and sub-tasks using TaskCreate.
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.
