home / skills / levnikolaevich / claude-code-skills / ln-781-build-verifier

ln-781-build-verifier skill

/ln-781-build-verifier

This skill detects project types, restores dependencies, builds, and verifies artifacts to ensure reliable production-ready results.

npx playbooks add skill levnikolaevich/claude-code-skills --skill ln-781-build-verifier

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.0 KB
---
name: ln-781-build-verifier
description: Builds all detected projects and verifies successful compilation
---

> **Paths:** File paths (`shared/`, `references/`, `../ln-*`) are relative to skills repo root. If not found at CWD, locate this SKILL.md directory and go up one level for repo root.

# ln-781-build-verifier

**Type:** L3 Worker
**Category:** 7XX Project Bootstrap
**Parent:** ln-780-bootstrap-verifier

---

## Purpose

Detects project types, restores dependencies, executes builds, and verifies successful compilation.

**Scope:**
- Auto-detect project types from file markers
- Restore dependencies using appropriate package manager
- Execute build commands for each project
- Verify build artifacts exist

**Out of Scope:**
- Running tests (handled by ln-782)
- Container operations (handled by ln-783)
- Workflow orchestration (handled by ln-780)

---

## When to Use

| Scenario | Use This Skill |
|----------|---------------|
| Called by ln-780 orchestrator | Yes |
| Standalone build verification | Yes |
| CI/CD pipeline build step | Yes |
| Test execution needed | No, use ln-782 |

---

## Workflow

### Step 1: Detect Project Types

Scan project root for type markers.

| Marker File | Project Type | Build System |
|------------|--------------|--------------|
| package.json | Node.js/Frontend | npm/yarn/pnpm |
| *.csproj | .NET | dotnet |
| setup.py / pyproject.toml | Python | pip/poetry |
| go.mod | Go | go build |
| Cargo.toml | Rust | cargo |
| pom.xml | Java/Maven | mvn |
| build.gradle | Java/Gradle | gradle |

### Step 2: Restore Dependencies

For each detected project, restore dependencies before building.

| Project Type | Dependency Restoration |
|--------------|----------------------|
| Node.js | Install packages from lock file |
| .NET | Restore NuGet packages |
| Python | Install from requirements or pyproject |
| Go | Download modules |
| Rust | Fetch crates |

### Step 3: Build Projects

Execute build for each project type in Release/Production mode.

| Project Type | Build Mode | Expected Outcome |
|--------------|-----------|------------------|
| Node.js | Production | Bundled assets in dist/ or build/ |
| .NET | Release | Compiled DLLs in bin/Release/ |
| Python | Editable install | Package installed in environment |
| Go | Production | Compiled binary |
| Rust | Release | Optimized binary in target/release/ |

### Step 4: Verify Build Artifacts

Confirm build outputs exist.

| Project Type | Artifact Check |
|--------------|---------------|
| Node.js | dist/ or build/ directory exists, contains files |
| .NET | DLL files in bin/Release/{framework}/ |
| Python | Package importable |
| Go | Binary executable exists |
| Rust | Binary in target/release/ |

### Step 5: Report Results

Return structured results to orchestrator.

**Result Structure:**

| Field | Description |
|-------|-------------|
| projectName | Name of the project |
| projectType | Detected type (nodejs, dotnet, python, etc.) |
| status | success / failed |
| duration | Build time in seconds |
| outputPath | Path to build artifacts |
| errorMessage | Error details if failed |

---

## Error Handling

| Error Type | Recovery Action |
|------------|----------------|
| Dependency restore failed | Check network, verify lock file integrity |
| Compilation errors | Log full error output, report as failed |
| Missing build tool | Report required tool installation |
| Timeout | Report timeout, suggest increasing limit |

---

## Critical Rules

1. **Always restore dependencies first** - builds may fail without fresh dependencies
2. **Use production/release mode** - development builds may hide issues
3. **Verify artifacts exist** - successful exit code is not sufficient
4. **Report all projects** - include both successful and failed builds

---

## Definition of Done

- [ ] All project types detected
- [ ] Dependencies restored for each project
- [ ] Build executed for each project
- [ ] Artifacts verified to exist
- [ ] Results returned to orchestrator

---

## Reference Files

- Parent: `../ln-780-bootstrap-verifier/SKILL.md`

---

**Version:** 2.0.0
**Last Updated:** 2026-01-10

Overview

This skill detects multiple project types in a repository, restores dependencies, executes production/release builds, and verifies that compilation artifacts exist. It returns structured results per project so an orchestrator or CI step can decide next actions. It focuses on build verification only; testing and container work are handled by companion skills.

How this skill works

The skill scans the repository root for marker files to identify project types (Node.js, .NET, Python, Go, Rust, Java, etc.). For each detected project it restores dependencies with the appropriate package manager, runs the designated build command in release/production mode, and checks for expected artifacts (dist/, bin/Release, binary executables, target/release, etc.). It collects timings, status, output paths, and any error messages into a structured result for downstream consumption.

When to use it

  • Called by an orchestration step to validate builds across a mono-repo or multi-project repo
  • As a standalone CI/CD build verification step before packaging or deployment
  • During developer workflows to ensure project bootstraps and builds reproducibly
  • When you need to confirm artifacts exist after compilation but do not need to run tests
  • Before running containerization or runtime checks handled by other skills

Best practices

  • Always run dependency restoration before attempting builds to avoid transient failures
  • Use production or release build modes to catch optimization-related issues
  • Fail builds on missing artifacts even if tool exit codes are zero
  • Set sensible timeouts per project type and report timeouts clearly
  • Capture and surface full build logs and error outputs for faster triage

Example use cases

  • CI pipeline step that builds all detected services in a mono-repo and reports artifact locations
  • Pre-merge check to ensure new code compiles across all affected projects
  • Orchestrator task that validates bootstrap success after environment provisioning
  • Automated gate that blocks deployment when any project fails to produce expected artifacts

FAQ

Which project types are supported?

Detects common markers: package.json (Node), *.csproj (.NET), pyproject.toml/setup.py (Python), go.mod (Go), Cargo.toml (Rust), pom.xml/build.gradle (Java).

Does it run tests?

No. This skill focuses on dependency restore, build, and artifact verification. Use the dedicated test skill for test execution.