solid-enforcer

Enforce SOLID design principles in TS/JS/Python code generation and review.

1|Updated Jan 15, 2026
One-click install
npx skills add https://github.com/janjaszczak/cursor --skill solid-enforcer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: solid-enforcer
Source: https://github.com/janjaszczak/cursor/tree/main/skills/solid
Command: npx skills add https://github.com/janjaszczak/cursor --skill solid-enforcer

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enforce SOLID design principles across generation, refactor, and code review to improve maintainability and extensibility, helping teams reduce coupling and increase clarity of interfaces and responsibilities.

Core Features & Use Cases

  • SRP, OCP, LSP, ISP, and DIP enforcement during creation, modification, and review of code.
  • A structured refactor playbook with explicit dependency management, small, focused modules, and testability as core invariants.
  • Guidance for architecture changes, introducing new abstractions, and maintaining stable behavior across PRs and code generation tasks.

Quick Start

Activate the SOLID Enforcer when starting a project or reviewing PRs to ensure designs adhere to SOLID principles.

Frequently Asked Questions about solid-enforcer

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

FAQPage Schema
How do I enforce SOLID design principles during code generation and PR reviews?

To enforce SOLID design during code generation and PR reviews, apply a structured refactor playbook that checks SRP, OCP, LSP, ISP, and DIP constraints through explicit dependencies, small modules, and contract tests.

Can I use a SOLID refactoring playbook to reduce coupling in TypeScript and Python repositories?

Yes, you can apply SOLID refactoring playbooks to reduce coupling in TypeScript, JavaScript, and Python repositories by introducing new abstractions and maintaining stable behavior through explicit dependency management and contract checks.

What is the best way to refactor code for Single Responsibility Principle without breaking existing tests?

The best way to refactor code for Single Responsibility Principle without breaking tests is to split into small, focused modules while running contract checks to maintain stable behavior and ensure testability as a core invariant.

Does dependency injection enforcement work with JavaScript and TypeScript architecture changes?

Yes, dependency injection enforcement works with JavaScript and TypeScript architecture changes by applying the Dependency Inversion Principle to establish explicit dependencies, reduce coupling, and clarify interfaces during generation tasks.

How do I check LSP and ISP compliance when introducing new abstractions in a codebase?

To check LSP and ISP compliance when introducing new abstractions, enforce clearer interfaces and verify behavioral subtypes through structured contract checks and testability invariants during code reviews.

When should I not apply a strict SOLID architecture refactor to my project?

You should avoid a strict SOLID architecture refactor when your project lacks adequate test coverage, as the process relies on running contract checks and testability invariants to maintain stable behavior across module splits.