Skip to content
Skills Library
Programming · Building & coding

solid-python

/solid-python

Use when writing or refactoring Python code, structuring modules/[feature]/ layers, or defining Protocol-based interfaces (SOLID, files within FUSE_SOLID_MAX_LINES).

Repository
agents ↗
Licence
MIT
Last repository change
12.10.2026

Assessment and security

90/ 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.
Content25 / 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
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.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 when writing or refactoring Python code, structuring modules/[feature]/ layers, or defining Protocol-based interfaces (SOLID, files within FUSE_SOLID_MAX_LINES).

Original author description

Use when writing or refactoring Python code, structuring modules/[feature]/ layers, or defining Protocol-based interfaces (SOLID, files within FUSE_SOLID_MAX_LINES).

How it works

  1. Agent Workflow (MANDATORY)
  2. DRY - Reuse Before Creating (MANDATORY)
  3. Architecture (Modules MANDATORY)
  4. Critical Rules (MANDATORY)
  5. Reference Guide
  6. Forbidden
Original SKILL.md headings · 78 lines, 401 words
SKILL.md preview
---
name: solid-python
description: "Use when writing or refactoring Python code, structuring modules/[feature]/ layers, or defining Protocol-based interfaces (SOLID, files within FUSE_SOLID_MAX_LINES)."
versions:
  python: "3.14"
user-invocable: true
references: references/principles.md, references/patterns.md
related-skills: solid-detection
---

<objective>
SOLID Python enforces a modular architecture for Python 3.14+: every feature lives under `modules/[feature]/` (routes, services, repositories, interfaces, models) with shared code in `core/`, interfaces are defined with `typing.Protocol` and live only in `interfaces/` directories, type hints are mandatory on every signature, and every public function carries a docstring.

Before writing any new code it requires a DRY check against `core/services` and `core/interfaces`. See `principles.md` for the 5 SOLID principles and `patterns.md` for directory layout, testing, and typing conventions.
</objective>

# SOLID Python - Modular Architecture

## Agent Workflow (MANDATORY)

Before ANY implementation, spawn 3 agents in parallel, one `Agent` call each with a `name`:

1. **fuse-ai-pilot:explore-codebase** - Analyze existing architecture
2. **fuse-ai-pilot:research-expert** - Verify Python docs via Context7
3. **fuse-ai-pilot:sniper** - Post-implementation validation

---

## DRY - Reuse Before Creating (MANDATORY)

**Before writing ANY new code:**
1. **Grep the codebase** for similar interfaces, services, or logic
2. Check shared locations: `core/services/`, `core/interfaces/`
3. If similar code exists -> extend/reuse instead of duplicate
4. If code will be used by 2+ features -> create it in `core/`

---

## Architecture (Modules MANDATORY)

| Layer | Location |
|-------|----------|
| Routes | `modules/[feature]/routes/` |
| Services | `modules/[feature]/services/` |
| Repositories | `modules/[feature]/repositories/` |
| Interfaces | `modules/[feature]/interfaces/` |
| Models | `modules/[feature]/models/` |
| Shared | `core/{services,interfaces,models}/` |

**NEVER use flat `src/` structure - always `modules/[feature]/`**

---

## Critical Rules (MANDATORY)

| Rule | Value |
|------|-------|
| File limit | `FUSE_SOLID_MAX_LINES` |
| Routes | Thin, delegate to services |
| Interfaces | `interfaces/` directory ONLY |
| Docstrings | Every public function documented |
| Type hints | MANDATORY on all signatures |
| Protocols | Use `typing.Protocol` for interfaces |
| Small interfaces | 1-3 methods max |

---

## Reference Guide

| Topic | Reference | When to consult |
|-------|-----------|-----------------|
| **SOLID Principles** | [principles.md](references/principles.md) | Quick reference for all 5 principles |
| **Patterns & Structure** | [patterns.md](references/patterns.md) | Directory layout, testing, typing |

---

## Forbidden

| Anti-Pattern | Fix |
|--------------|-----|
| Files over `FUSE_SOLID_MAX_LINES` | Split by responsibility |
| Interfaces in impl files | Move to `interfaces/` directory |
| Fat interfaces (4+ methods) | Split into small Protocols |
| Flat `src/` structure | Use `modules/[feature]/` |
| Concrete dependencies | Use Protocol + dependency injection |
| Missing type hints | Add type annotations to all signatures |
Files in this package (3)
  • SKILL.md 3 KB
  • references/patterns.md 2 KB
  • references/principles.md 2 KB

Versions

The database has no other skills named solid-python.

Database snapshot: 13.11.2026 · package version ef84ba511de3 (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

  • 90solid-go
    Use when writing or refactoring Go code, structuring internal/modules/[feature]/ layers, or defining ports/ interfaces (SOLID, files within FUSE_SOLID_MAX_LINES).
  • 90solid-csharp
    Use when writing or refactoring C#/.NET code, structuring Modules/[Feature]/ layers, or defining Contracts/ interfaces (SOLID, files within FUSE_SOLID_MAX_LINES).
  • 100solid-principles-code-review-compliance
    Use this skill when review object-oriented architectures for compliance with SOLID software design principles.
  • 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.
  • 100code-refactoring-refactor-clean
    Refactor code with clean code principles, SOLID design patterns, and modern software engineering practices to improve quality, maintainability, and performance. Use when cleaning up or restructuring existing code.
  • 100clean-code
    Use when writing or reviewing code for readability, maintainability, and expressiveness — based on Robert C. Martin's "Clean Code." USE FOR: naming conventions, function design, comment quality, formatting standards, error handling strategy, code readability improvements DO NOT…

Feedback and reports

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