Skip to content
Skills Library
Programming · Review & audit

beyond-solid-principles

/beyond-solid-principles

This skill should be used when the user asks to "check architecture principles", "audit system design", "review code for coupling", "find architecture smells", or "improve system-level design". Also triggers when the user mentions a principle by name (e.g., "check separation of concerns", "is this violating DRY?", "Law of Demeter", "KISS", "YAGNI", "resilience", "evolvability", "loose coupling"). Supports checking all ten principles at once or focusing on a single principle.

Repository
claude-code ↗
Licence
MIT
Last repository change
07.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
11
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

This skill should be used when the user asks to "check architecture principles", "audit system design", "review code for coupling", "find architecture smells", or "improve system-level design". Also triggers when the user mentions a principle by name (e.g., "check separation of concerns", "is this violating DRY?", "Law of Demeter", "KISS", "YAGNI", "resilience", "evolvability", "loose coupling"). Supports checking all ten principles at once or focusing on a single principle.

Triggers from the description

check architecture principlesaudit system designreview code for couplingfind architecture smellsimprove system-level designcheck separation of concernsis this violating DRY?Law of Demeter
Original author description

This skill should be used when the user asks to "check architecture principles", "audit system design", "review code for coupling", "find architecture smells", or "improve system-level design". Also triggers when the user mentions a principle by name (e.g., "check separation of concerns", "is this violating DRY?", "Law of Demeter", "KISS", "YAGNI", "resilience", "evolvability", "loose coupling"). Supports checking all ten principles at once or focusing on a single principle.

How it works

  1. Subcommands
  2. Workflow
  3. Pragmatism Guidelines
  4. Example Interaction
Original SKILL.md headings · 140 lines, 846 words
SKILL.md preview
---
name: beyond-solid-principles
version: 1.0.0
description: >
  This skill should be used when the user asks to "check architecture principles",
  "audit system design", "review code for coupling", "find architecture smells", or
  "improve system-level design". Also triggers when the user mentions a principle by
  name (e.g., "check separation of concerns", "is this violating DRY?", "Law of
  Demeter", "KISS", "YAGNI", "resilience", "evolvability", "loose coupling"). Supports
  checking all ten principles at once or focusing on a single principle.
disable-model-invocation: true
---

# Beyond SOLID — System-Level Architecture Principles

Analyze source code and system architecture for violations of ten foundational design
principles that govern how modules, services, layers, and components are structured
and interact. Produce actionable findings with severity ratings, code/architecture
locations, and concrete remediation suggestions.

These principles operate at the architecture scale — modules, services, bounded
contexts, layers, APIs — complementing the class-level SOLID principles.

## Subcommands

Request a full audit or focus on a single principle:

| Command Pattern | Principle | Reference |
|----------------|-----------|-----------|
| `sw-soc` | Separation of Concerns | `references/soc.md` |
| `sw-srp-sys` | Single Responsibility (system-level) | `references/srp-sys.md` |
| `sw-dry` | Don't Repeat Yourself (DRY) | `references/dry.md` |
| `sw-demeter` | Law of Demeter / Principle of Least Knowledge | `references/demeter.md` |
| `sw-coupling` | Loose Coupling, High Cohesion | `references/coupling.md` |
| `sw-evolvability` | Build for Change (Evolvability) | `references/evolvability.md` |
| `sw-resilience` | Design for Failure / Resilience | `references/resilience.md` |
| `sw-kiss` | KISS — Keep It Simple | `references/kiss.md` |
| `sw-pola` | Principle of Least Surprise (POLA) | `references/pola.md` |
| `sw-yagni` | YAGNI at Architecture Level | `references/yagni.md` |
| `beyond-solid-principles` | All ten principles | All references |

When no subcommand is specified, default to checking all ten principles.
When a principle is mentioned by name (even without the command prefix), match it to
the appropriate subcommand.

## Workflow

### 1. Identify Target Code

Determine what code or architecture to analyze:
- When files or a directory are provided, use those.
- When a service, module, or component is referenced by name, locate it.
- When ambiguous, ask which files, directories, or services to scan.

These principles apply to any language and any architecture style — monoliths,
modular monoliths, microservices, serverless, event-driven, layered, hexagonal, etc.
Adapt the principle checks to the idioms and scale of the target system.

For smaller codebases, focus on module/package boundaries, dependency direction,
and internal layering. For distributed systems, also consider service boundaries,
API contracts, data ownership, messaging patterns, and operational resilience.

### 2. Load Principle References

Before analyzing, read the reference file(s) for the requested principle(s):

- [`references/soc.md`](references/soc.md) for Separation of Concerns
- [`references/srp-sys.md`](references/srp-sys.md) for Single Responsibility (system-level)
- [`references/dry.md`](references/dry.md) for DRY
- [`references/demeter.md`](references/demeter.md) for Law of Demeter
- [`references/coupling.md`](references/coupling.md) for Loose Coupling, High Cohesion
- [`references/evolvability.md`](references/evolvability.md) for Build for Change
- [`references/resilience.md`](references/resilience.md) for Design for Failure
- [`references/kiss.md`](references/kiss.md) for KISS
- [`references/pola.md`](references/pola.md) for Principle of Least Surprise
- [`references/yagni.md`](references/yagni.md) for YAGNI

For a full audit (`beyond-solid-principles`), read all ten.

### 3. Analyze

For each target file, module, or service boundary, apply the violation patterns from
the loaded references. Think carefully about each pattern — not every heuristic match
is a true violation. Consider context, system scale, team size, and maturity.

Key analysis dimensions:
- **Static structure**: dependency direction, import graphs, layer boundaries.
- **Change patterns**: which files/modules change together (if VCS history is available).
- **Runtime topology**: service call chains, data flow, failure propagation paths.
- **API contracts**: consistency, encapsulation, versioning, naming conventions.
- **Operational posture**: timeouts, retries, circuit breakers, health checks.

### 4. Report Findings

Present findings using this structure:

#### Per Violation

```
**[PRINCIPLE] Violation — Severity: HIGH | MEDIUM | LOW**
Location: `filename` or `service/module`, lines ~XX-YY (if applicable)
Issue: Clear description of what violates the principle and why it matters.
Suggestion: Concrete remediation approach with brief code or architecture sketch if helpful.
```

Severity guidelines:
- **HIGH**: Active maintenance pain, production risk, blocks independent evolution,
  or causes cascading failures.
- **MEDIUM**: Architecture smell that will cause problems as the system grows or
  as more teams contribute.
- **LOW**: Minor design impurity, worth noting but fine to defer.

#### Summary

After all findings, provide:
- A count table: `| Principle | HIGH | MEDIUM | LOW |`
- Top 3 priorities: which violations to fix first and why.
- Overall assessment: one paragraph on the system's structural health and
  evolvability posture.

### 5. Refactor Mode (Optional)

When a fix or refactoring is requested (e.g., "fix this", "refactor it",
"show me the clean version"), produce refactored code or an architecture proposal
that resolves the identified violations. Explain each change briefly.

## Pragmatism Guidelines

These are guidelines, not laws. Apply judgment:

- Small projects and prototypes get a lighter touch. Don't flag a weekend project
  for lacking circuit breakers or API versioning.
- Some "violations" are conscious trade-offs. When a rationale is documented (e.g.,
  in an ADR), acknowledge it rather than insisting on purity.
- Scale matters. A single-service CRUD app does not need the same architectural rigor
  as a platform serving millions of requests. Calibrate severity to context.
- Principles have productive tensions. DRY conflicts with loose coupling across service
  boundaries. KISS conflicts with resilience patterns. YAGNI conflicts with evolvability.
  Flag the tension and offer judgment, not dogma.
- Prefer actionable findings over exhaustive catalogs. Five important findings
  beat twenty trivial ones.

## Example Interaction

**User**: `sw-coupling` (with a codebase directory)

**Claude**:
1. Reads `references/coupling.md`
2. Analyzes the directory for coupling/cohesion violations
3. Reports findings with locations, severity, and suggestions
4. Provides a summary with priorities
Files in this package (11)
  • SKILL.md 7 KB
  • references/coupling.md 6 KB
  • references/demeter.md 6 KB
  • references/dry.md 6 KB
  • references/evolvability.md 6 KB
  • references/kiss.md 6 KB
  • references/pola.md 6 KB
  • references/resilience.md 7 KB
  • references/soc.md 7 KB
  • references/srp-sys.md 7 KB
  • references/yagni.md 7 KB

Versions

The database has no other skills named beyond-solid-principles.

Database snapshot: 13.11.2026 · package version c1987e9840c6 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100solid-principles
    This skill should be used when the user asks to "check SOLID violations", "audit class design", "review code quality", "find design smells", or "improve object-oriented architecture". Also triggers when the user mentions a principle by name (e.g., "check SRP", "is this violating…
  • 100clean-code-principles
    SOLID principles, design patterns, DRY, KISS, and clean code fundamentals. Use when reviewing architecture, checking code quality, refactoring, or discussing design decisions. Triggers on "review architecture", "check code quality", "SOLID principles", "design patterns", or "clean code".
  • 100react-principles
    Principles and practices for writing React: SOLID, DRY/KISS/YAGNI, Hooks, state, effects, TypeScript and testing. Use when creating, refactoring or reviewing React components, Hooks, props or frontend structure.
  • 100dev-software-design
    Opinionated guide to software design principles and architectural patterns. Use when reviewing code design, planning feature architecture, asking "is this the right design?", "how should I structure this?", or requesting design philosophy guidance. Triggers on questions about…
  • 85backend-code-quality-review
    Use when reviewing backend code for SOLID/DRY/KISS/YAGNI violations, naming, cohesion, and coupling. Triggers when source files in a backend stack (Java, Kotlin, Python, Node/TS, Go) are in scope. Skip for infrastructure code (Terraform, K8s manifests).
  • 100code-quality-principles
    Applies KISS, YAGNI, and SOLID principles for clean code with reduced complexity. Use when refactoring or reviewing code for over-engineering.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.