architecture-drift-radar

Compare design intent against codebase evidence to generate drift reports.

Updated Jun 1, 2026
One-click install
npx skills add https://github.com/aurora-atoms/lattice --skill architecture-drift-radar
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-drift-radar
Source: https://github.com/aurora-atoms/lattice/tree/main/skills/architecture-drift-radar
Command: npx skills add https://github.com/aurora-atoms/lattice --skill architecture-drift-radar

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the silent accumulation of technical debt and structural decay by identifying where the actual implementation of a system has drifted away from its documented architectural intent.

Core Features & Use Cases

  • Drift Detection: Compares versioned design intent against current code, configuration, and runtime evidence to highlight discrepancies.
  • Pattern Analysis: Distinguishes between isolated, acceptable exceptions and systemic, cumulative drift patterns that threaten system integrity.
  • Use Case: Use this during major refactoring preparation or incident analysis to visualize how individual, reasonable changes have collectively altered system boundaries or control flows over time.

Quick Start

Use the architecture-drift-radar skill to compare the current system implementation against the latest architecture intent document and generate a drift report.

Frequently Asked Questions about architecture-drift-radar

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is architecture drift and how does it impact system integrity?

Architecture drift is the cumulative divergence between documented design intent and observed implementation evidence. It silently accumulates technical debt and structural decay, threatening system integrity when reasonable changes collectively alter system boundaries or control flows over time.

How do I detect architectural divergence before starting a major refactoring?

To detect architectural divergence before refactoring, compare your versioned design intent documents against current codebase, configuration state, and runtime evidence. This generates a drift report with impact assessments, highlighting discrepancies between intended architecture and actual implementation.

Can I analyze architecture drift using only codebase evidence and configuration state?

Analyzing architecture drift requires structured inputs of design intent, codebase evidence, and configuration state. You must supply documented architectural intent alongside observed implementation data to produce actionable drift reports that assess structural impact.

What is the best way to distinguish isolated exceptions from systemic architectural drift?

The best way to distinguish isolated exceptions from systemic architectural drift is through pattern analysis. This technique compares versioned design intent against current implementation evidence to identify whether discrepancies represent acceptable exceptions or cumulative drift threatening system integrity.

How does architecture drift analysis work during incident analysis?

During incident analysis, architecture drift analysis works by comparing current implementation evidence against documented design intent to visualize how individual changes have collectively altered control flows. It produces actionable drift reports with impact assessments for complex software systems.

When should I not use a drift detection approach for architecture compliance?

You should not use drift detection when you lack structured inputs of design intent, codebase evidence, and configuration state. Without versioned architecture documents to compare against observed implementation, generating actionable drift reports with accurate impact assessments is not possible.