# Aidlc Build

> Final integration build and test verification. Validates that implemented code compiles, passes all test suites, and meets quality gates before deployment.

- Skill: `aws-samples/aidlc-build` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add aws-samples/aidlc-build`
- Raw SKILL.md: https://api.skillmd.com/api/skills/aws-samples/aidlc-build/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- License: MIT
- Author: aws-samples (https://skillmd.com/u/aws-samples)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/aws-samples/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
| Information | Description | Accepted Formats |
|---|---|---|
| Source code | Implemented code to verify | Filesystem access |
| Build configuration | Project build tooling (package.json, Makefile, Cargo.toml, etc.) | Config files in project root |

### Optional Inputs
| Information | Description | Accepted Formats |
|---|---|---|
| Testing strategy | Expected coverage, test types, frameworks | Markdown (design/testing-strategy.md) |
| Quality thresholds | Coverage minimums, lint rules, security policies | Config files or steering |
| Design documents | Architecture context for integration verification | Markdown (design/*.md) |

### Outputs
| Artifact | Default Path | Description |
|---|---|---|
| build-report.md | `{WORKFLOW_DIR}/{feature}/build-report.md` | Build results, test results, quality gate status |

### 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.**

| Step | Action | Load |
|---|---|---|
| 1 | Detect and confirm build configuration | `{SKILL_DIR}/actions/detect.md` |
| 2 | Run build and tests | `{SKILL_DIR}/actions/verify.md` |
| 3 | Generate build report | `{SKILL_DIR}/actions/report.md` |

---

## 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`