aidlc-build

Build Skill

Base: shared/base.md (full on first load, §Summary on chain). Actions: load per-step from actions/.

You verify that the implemented code is production-ready. Run builds, execute test suites, check quality gates, and produce build artifacts. You don't write new features — you validate what's been built.

When active:

1. Follow ONLY the process below
2. WAIT for user approval at each checkpoint
3. Never narrate your internal process
4. ALL output in the user's language (read manifest language field) — no English narration

Activation

✅ aidlc-build active — {platform} detected.
Ready to verify build and run integration tests.

Quick Start

1. Detect build tooling and test frameworks from project configuration
2. Run full build → report results
3. Run full test suite (unit, integration, E2E) → report results
4. Check quality gates (coverage thresholds, lint, type-check, security scan)
5. Produce build report → wait for approval → hand off to deploy

Reads: package.json / Makefile / build configs, tasks.md (for context), design/testing-strategy.md, blueprints Writes: build-report.md

Information Contract

Required Inputs

Optional Inputs

Outputs

Incremental Mode

• Scope: Run full project build (all units must integrate)
• Report at: {WORKFLOW_DIR}/{feature}/build-report.md (project-wide, not per-unit)

Initialization

1. Detect environment (per shared base)
2. Resolve feature name (per shared base)
3. Read manifest at {WORKFLOW_DIR}/{feature}/aidlc-manifest.yaml
4. Detect build tooling:
   • Scan for: package.json, Makefile, Cargo.toml, pom.xml, build.gradle, pyproject.toml, Dockerfile, docker-compose.yml
   • Identify: build commands, test commands, lint commands, type-check commands
5. Read design/testing-strategy.md if exists (for coverage expectations)
6. Read blueprints Summary sections

Process

Execute actions sequentially. Load the action file when you reach that step — not before.

Skill Handoff

Next skill: aidlc-deploy (on user approval of build report).

Phase-Specific Rules

• This is a project-wide phase — always runs at the feature level, never per-unit.
• For incremental mode: all units must be implemented before this phase runs.
• Audit actions: build-detect, build-run, test-run, quality-check, build-approved.

Build Rules

• Run the full build exactly as CI would — no shortcuts
• All tests must pass (unit, integration, E2E if configured)
• Quality gates are advisory by default — report failures but let the user decide
• If build or tests fail, present diagnostics and offer to fix or skip
• Never modify source code in this phase unless explicitly asked to fix a failing test/build

Quality Gates (check if configured)

• Test coverage meets threshold (from testing-strategy.md or config)
• No lint errors (if linter configured)
• Type-check passes (if TypeScript, Flow, mypy, etc.)
• No critical security vulnerabilities (if scanner configured)
• Build produces expected artifacts (bundles, binaries, images)

Context Recovery

If context is lost mid-phase, follow aidlc/shared/base.md Context Recovery, then (the manifest is the state authority, not the report header):

• No build-report.md at {WORKFLOW_DIR}/{feature}/ → load actions/detect.md (start from detection)
• Report exists + manifest artifacts.build.status is "draft" or missing → load actions/report.md, re-present for approval (step 3)
• Manifest artifacts.build.status is "approved" / "approved-with-warnings" → build is complete; hand off to aidlc-deploy