Skip to content
Skills Library
Programming · Review & audit

solid-principles-code-review-compliance

/solid-principles-code-review-compliance

Use this skill when review object-oriented architectures for compliance with SOLID software design principles.

Licence
MIT
Last repository change
28.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 28.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

Use this skill when review object-oriented architectures for compliance with SOLID software design principles.

Original author description

Use this skill when review object-oriented architectures for compliance with SOLID software design principles.

How it works

  1. When to use
  2. Core principles
  3. Step-by-step workflow
  4. Specifics & examples
  5. Common mistakes & pitfalls
  6. Verification checklist
  7. Related skills
Original SKILL.md headings · 41 lines, 366 words
SKILL.md preview
---
name: solid-principles-code-review-compliance
description: Use this skill when review object-oriented architectures for compliance with SOLID software design principles.
---
# SOLID Principles Code Review Compliance

## When to use
Use this skill when review object-oriented architectures for compliance with SOLID software design principles. This applies across software engineering lifecycles, team code reviews, production debugging, prompt design, and architectural documentation.

## Core principles
- **Clarity Over Cleverness**: Code, prompts, and technical documentation must prioritize clarity, predictability, and long-term maintainability over obscure shortcuts.
- **Evidence-Based Engineering**: Every decision, bug resolution, and architectural choice must be supported by empirical data, minimal reproductions, or benchmark traces.
- **Cognitive Load Minimization**: Design interfaces, APIs, and documents to minimize mental parsing overhead for future engineers and autonomous agents.
- **Continuous Feedback Loops**: Incorporate automated verification, peer reviews, and post-task retrospectives to drive iterative improvement.

## Step-by-step workflow
1. **Define the objective and constraints**: State the exact technical outcome, acceptance criteria, and operational boundaries.
2. **Gather baseline telemetry and context**: Inspect relevant codebases, stack traces, system architecture diagrams, or log files.
3. **Execute structured analysis or implementation**: Apply domain-specific techniques (e.g., minimal reproduction, refactoring transforms, prompt templates).
4. **Validate against automated test assertions**: Run unit tests, linters, or schema validation parsers to verify behavioral correctness.
5. **Document rationale and trade-offs**: Record the 'why' behind choices, documenting rejected alternatives and operational considerations.
6. **Conduct retrospective review**: Share findings with stakeholders or record lessons learned in the team knowledge base.

## Specifics & examples
- **Standard Engineering Artifact**:
  - Scope: SOLID Principles Code Review Compliance
  - Core Deliverable: Actionable, verifiable engineering guidance aligned with Code review & refactoring.
  - Verification Rule: Tested against production workflows and peer-reviewed standards.
- **Primary Focus Area**: Code review & refactoring principles designed to elevate engineering precision and team psychological safety.

## Common mistakes & pitfalls
- Jumping directly into speculative fixes or complex rewrites before isolating the root cause.
- Introducing premature abstractions that increase indirection and cognitive complexity.
- Failing to document context and architectural trade-offs for subsequent maintainers.

## Verification checklist
[ ] The technical deliverable or fix is validated with reproducible test assertions.
[ ] Changes preserve backwards compatibility and maintain existing contract invariants.
[ ] Documentation or commit logs clearly explain the rationale and trade-offs.

## Related skills
- pull-request-review-comprehensive-checklist
- constructive-code-review-feedback-empathy
- technical-debt-identification-backlog-prioritization

Versions

The database has no other skills named solid-principles-code-review-compliance.

Database snapshot: 13.11.2026 · package version 1c98d2ee725a (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
    Audits code for adherence to the five SOLID principles and reports violations with concrete fixes. Use when reviewing class design, dependency structure, or object-oriented quality.
  • 100solid-review
    SOLID design-principles review (SRP / OCP / LSP / ISP / DIP) on a file/directory/glob. Review-only. Triggers on `/solid-review`, \"SOLID review\", \"design review\", \"design principles\", \"SOLID 검증\", \"디자인 리뷰\", \"원칙 검증\", or `/deep-test` running it as the Advisory Gate.
  • 100code-review
    Performs architectural and quality code review checking coding standards, SOLID principles, architectural compliance, and common software issues. Use when reviewing a file or directory before merge, or when the user mentions code review, PR review, or quality check.
  • 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-architecture
    Review code and provide design guidance based on Clean Architecture principles. Checks dependency rule, layer separation, crossing boundaries, and SOLID principles. Use when asked to review architecture, check dependencies, or design with clean architecture principles.
  • 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".

Feedback and reports

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