architecture-evaluation-framework

Assess software architectures for SOLID adherence and coupling metrics.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/doctorduke/claude-config --skill architecture-evaluation-framework
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-evaluation-framework
Source: https://github.com/doctorduke/claude-config/tree/main/skills/architecture-evaluation-framework
Command: npx skills add https://github.com/doctorduke/claude-config --skill architecture-evaluation-framework

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Poor architecture leads to technical debt, performance issues, and costly refactoring. This Skill provides a structured way to analyze your system's architecture, identify patterns, detect anti-patterns, and ensure adherence to best practices like SOLID principles, saving you from future headaches and ensuring long-term maintainability.

Core Features & Use Cases

  • Pattern & Anti-Pattern Detection: Automatically identify architectural patterns (e.g., layered, microservices) and anti-patterns (e.g., circular dependencies, God objects).
  • SOLID Principles & Metrics: Evaluate code for SOLID compliance and measure coupling/cohesion to pinpoint refactoring needs.
  • C4 Model Generation: Automatically generate hierarchical C4 diagrams (Context, Container, Component) to visualize and document your system.
  • Use Case: You've inherited a large codebase and need to understand its structure and identify potential issues. Use this Skill to generate a comprehensive architecture report, including dependency graphs, SOLID violations, and C4 diagrams, giving you a clear roadmap for improvements.

Quick Start

Analyze the Python project in 'src/' for SOLID principle violations and generate a report.

Frequently Asked Questions about architecture-evaluation-framework

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

FAQPage Schema
How do I analyze code for SOLID principle violations in my codebase?

SOLID analysis evaluates adherence to five design principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—by examining coupling, cohesion, and dependency patterns. This Skill automatically identifies violations across multi-language codebases and reports refactoring priorities.

Can I detect architectural anti-patterns like circular dependencies and God objects automatically?

Yes, pattern and anti-pattern detection identifies layered, microservices, and monolithic structures, then flags issues such as circular dependencies, God objects, and tightly-coupled components. The Skill uses AST-based analysis and dependency graph construction to pinpoint these problems.

What's the best way to document and visualize system architecture with C4 diagrams?

C4 model generation automatically produces hierarchical Context, Container, and Component diagrams from your codebase structure. This Skill creates both visual documentation and Markdown or JSON exports, eliminating manual diagram maintenance and ensuring architecture documentation stays current.

How do I quantify technical debt and coupling metrics in my existing system?

Metric computation measures coupling, cohesion, and quality attributes across your architecture to quantify technical debt. The Skill generates ATAM-style evaluations and reports highlighting which modules or services contribute most to debt and refactoring impact.

Does this work for assessing both monolithic and microservice architectures?

Yes, the Skill applies to both monoliths and microservices, supporting architecture risk assessment for either pattern. It analyzes multi-language codebases to evaluate dependency structures, scaling readiness, and service boundaries specific to each architectural style.

What output formats does the architecture analysis report provide?

Reports are generated in Markdown or JSON, enabling integration with documentation systems and automated workflows. Outputs include dependency graphs, SOLID violation summaries, coupling metrics, and C4 diagrams for comprehensive architecture communication.