Demo

Keep AI-generated code from breaking your architecture

AI tools generate working code quickly. They do not reliably preserve architecture boundaries, public entrypoints, dependency contracts, or architecture decisions.

ArchPilot makes architecture explicit and continuously verifiable in VS Code, CLI, and CI.

  • Module boundaries
  • Dependency contracts
  • Public entrypoints
  • ADR coverage
  • Architecture drift

Local-first. Deterministic. No AI required.

Walkthrough

From existing repository to improving architecture health.

The demo flow is intentionally local. ArchPilot works from repository metadata and deterministic rules so developers can inspect what changed before relying on it in review.

DetectInitializeValidateGenerate artifactsRerun checksConnect CI

Smart Init

Detect architecture from an existing repository

The Smart Init flow inspects repository structure, proposes architecture metadata, and gives developers a concrete starting point instead of a blank config file.

  • Shows detected modules, components, and conventions
  • Produces repository-local architecture metadata
  • Turns hidden structure into reviewable artifacts
Smart InitArchPilot Smart Init and validation flow detecting architecture and producing local metadata.

Validation

Find architecture drift before it reaches review

ArchPilot validates architecture rules locally. The same rule model can run from VS Code, the CLI, and CI without requiring AI or hosted code scanning.

  • Validates module boundaries and declared dependencies
  • Flags public entrypoint and architecture documentation drift
  • Produces repeatable findings developers can review
Local validationArchPilot VS Code extension running local architecture validation.

Findings

Turn architecture violations into actionable findings

Findings point to the rule, affected architecture surface, and next action so engineers can decide whether to fix code, update a contract, or document a decision.

  • Explains what boundary drift was detected
  • Connects findings to concrete architecture artifacts
  • Helps teams improve architecture health after regeneration and reruns
FindingsArchPilot findings view showing architecture validation results in VS Code.

Example output

Findings stay specific, reviewable, and architecture-shaped.

These are examples of the kind of signals ArchPilot surfaces. They are architecture validation findings, not runtime, vulnerability, or security scan claims.

$ archpilot validate

Architecture validation completed
Score: 84/100

high   AP-DEP-004   undeclared dependency
       billing -> risk/rules

medium AP-DEP-005   non-public import
       web imports payments/internal/repository

medium AP-ADR-004   ADR coverage missing
       tenant isolation configured without accepted ADR
AP-DEP-004

Undeclared cross-module dependency

billing imports risk/rules without a declared dependency in the module contract.

AP-DEP-005

Public entrypoint violation

web imports payments/internal/repository instead of the payments public entrypoint.

AP-ADR-004

Missing ADR coverage

tenant isolation is configured, but no accepted ADR explains the decision.

DRIFT

Architecture drift changed the score

Validation score moved from 91 to 84 after new dependency and documentation findings.

Workflow

The pieces skeptical developers expect to verify.

ArchPilot is designed as a repeatable architecture validation workflow, not a chat prompt or a hosted scanner.

Smart Init detects architecture

Start from an existing repo and generate reviewable architecture metadata instead of hand-writing the whole model.

Validate module and dependency boundaries

Run deterministic checks against contracts, public entrypoints, dependency rules, and architecture docs.

Generate missing contracts and config

Use local tooling to fill in architecture artifacts where the repository has enough structure to infer them.

Review findings in VS Code

Keep architecture feedback near the files engineers are editing, before drift reaches review.

Run the same checks in CLI and CI

The local validation workflow can run in terminals and pull request automation without hosted scanning.

Get PR architecture feedback

Use CI results and optional Cloud metadata to make architecture validation results visible during review.

Real repositories

Tested against real repositories

ArchPilot has been exercised against real-world codebases including ArchPilot itself, NestJS services, Next.js applications, Spring Boot projects, Laravel applications, and multi-component repositories.

The goal is practical architecture validation on existing codebases, not toy examples.

How this is different

ArchPilot complements existing tools by focusing on architecture governance.

It is most useful when teams already care about code quality and now need architecture boundaries to stay visible as AI-assisted changes accelerate.

ESLint / dependency-cruiser

Excellent for import rules. ArchPilot adds architecture contracts, findings, generated metadata, and governance workflow around those boundaries.

ArchUnit

Strong Java architecture testing. ArchPilot is multi-stack and shaped around editor, CLI, CI, and optional team visibility.

Nx

Great workspace and build tooling. ArchPilot focuses on architecture validation, module contracts, quality, and drift.

SonarQube

Broad code quality analysis. ArchPilot is specifically about architecture boundary governance and deterministic validation.

CI and PR review

Use the same architecture signal in pull requests.

Once the local loop is useful, teams can run the same validation in CI and optionally publish governance metadata for shared visibility in ArchPilot Cloud.

  • CI reinforces the local architecture checks
  • PR feedback can point reviewers to boundary drift
  • Cloud is optional team visibility, not the validator
CI validationGitHub Actions running ArchPilot architecture validation in CI.

Install and try

Start with the local tools, then add CI when the signal is useful.

Install the VS Code extension or try the CLI in an existing repository. Cloud can come later when your team wants shared architecture visibility.

Get started in minutes.

npm install -g @archpilotlabs/archpilot
archpilot --version
ArchPilot Demo | Local-First Architecture Validation