architecture-strategist

Detect architectural violations in code changes and recommend corrections.

1|Updated Apr 4, 2026
One-click install
npx skills add https://github.com/ybbms777/compound-engineering --skill architecture-strategist-ybbms777
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-strategist
Source: https://github.com/ybbms777/compound-engineering/tree/main/skills/agent-architecture-strategist
Command: npx skills add https://github.com/ybbms777/compound-engineering --skill architecture-strategist-ybbms777

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Unreviewed code changes often introduce architectural anti-patterns, break established component boundaries, create circular dependencies, and accumulate technical debt that erodes system maintainability and scalability over time. This Skill eliminates the risk of undetected architectural violations by providing a systematic, expert-level analysis of all code modifications against your system's documented and implicit design standards.

Core Features & Use Cases

  • Systematic Architectural Analysis: Evaluates code changes against established design patterns, SOLID principles, microservice boundaries, and system layering rules to ensure full alignment with existing architecture.
  • Proactive Violation Detection: Identifies high-risk architectural smells including circular dependencies, leaky abstractions, inappropriate component intimacy, and dependency rule violations before changes are merged.
  • Actionable Remediation Guidance: Provides structured, prioritized recommendations for correcting architectural issues, including pragmatic compromises when ideal solutions are not feasible, to balance system integrity with development velocity.
  • Real-World Use Case: When reviewing a PR that adds a new payment processing service, this Skill verifies the service follows existing microservice communication patterns, does not introduce circular dependencies with the order management service, and adheres to the project's dependency inversion rules.

Quick Start

Use the architecture-strategist skill to analyze the proposed changes in pull request #247 for compliance with the system's existing architectural patterns and design principles.

Frequently Asked Questions about architecture-strategist

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

FAQPage Schema
How do I detect architectural violations and SOLID principle breaches in a pull request?

Detect architectural violations and SOLID principle breaches in a pull request by auditing code changes against established design patterns and system boundaries. This analysis identifies circular dependencies, leaky abstractions, and inconsistent pattern usage before changes are merged.

What is the best way to review code changes for microservice boundary compliance?

Reviewing code changes for microservice boundary compliance requires evaluating modifications against documented microservice communication patterns and system layering rules. This ensures new services do not introduce inappropriate component intimacy or dependency rule violations.

How do I identify circular dependencies when adding a new service implementation?

Identify circular dependencies when adding a new service implementation by applying proactive architectural violation detection to the proposed code changes. This systematic analysis flags high-risk architectural smells and dependency rule violations before integration.

Can I get actionable remediation guidance for technical debt caused by leaky abstractions?

You can get actionable remediation guidance for technical debt caused by leaky abstractions through structured correction recommendations. This includes prioritized guidance for fixing architectural issues and pragmatic compromises when ideal solutions are not feasible.

Does this architectural compliance audit work for structural refactoring initiatives?

Architectural compliance audits work effectively for structural refactoring initiatives by evaluating modified code against established design patterns and system layering rules. This ensures alignment with existing architecture and prevents the accumulation of technical debt during refactoring.