Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

clean-architecture-refactor

/clean-architecture-refactor

Przebudowuje chaotyczną bazę kodu produkcyjnego według Clean Architecture: rozdziela odpowiedzialności, zwiększa modularność, zmniejsza sprzężenie i dostarcza nową strukturę folderów, kod i uzasadnienie bez zmiany zachowania produktu.

Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Przebudowuje chaotyczną bazę kodu produkcyjnego według Clean Architecture: rozdziela odpowiedzialności, zwiększa modularność, zmniejsza sprzężenie i dostarcza nową strukturę folderów, kod i uzasadnienie bez zmiany zachowania produktu.

Oryginalny opis (EN)

Act as a senior software architect rebuilding a messy production codebase using clean architecture principles: separate concerns properly, increase modularity, reduce tight coupling, improve scalability, and make the codebase easier to maintain long term. Delivers a new folder structure, a clean architecture breakdown, refactored production-grade code, and an explanation of the architectural improvements — without changing product behavior. Use when the user asks to refactor into clean/scalable architecture, restructure or modularize a messy codebase, separate concerns, reduce coupling, or reo

Jak działa

  1. Mission
  2. Critical Rules
  3. Workflow
  4. Output Format
Sekcje z nagłówków SKILL.md, w oryginale · 89 linii, 486 słów
Podgląd SKILL.md
---
name: clean-architecture-refactor
description: >
  Act as a senior software architect rebuilding a messy production codebase using clean architecture
  principles: separate concerns properly, increase modularity, reduce tight coupling, improve
  scalability, and make the codebase easier to maintain long term. Delivers a new folder structure, a
  clean architecture breakdown, refactored production-grade code, and an explanation of the
  architectural improvements — without changing product behavior. Use when the user asks to refactor
  into clean/scalable architecture, restructure or modularize a messy codebase, separate concerns,
  reduce coupling, or reorganize the folder/project structure. For .NET layered/DDD structure use
  dotnet:dotnet-architecture; for a non-mutating assessment first use senior-engineer-audit.
---

# Clean Architecture Refactor

Act like a senior software architect rebuilding a messy production codebase using clean architecture
principles. Refactor it like a real senior engineer preparing the codebase to scale.

## Mission

- Separate concerns properly
- Increase modularity
- Reduce tight coupling
- Improve scalability
- Make the codebase easier to maintain long term

## Critical Rules

**ALWAYS:**
- Delegate broad code reading to `Explore` subagents to understand the current structure before changing it.
- Preserve product behavior. This refactor improves **architecture and code quality only** — observable
  functionality must stay identical.
- Present the target structure and a migration plan, and get explicit user approval, BEFORE editing any
  code. This skill is the most mutating of the engineering-workflow skills — the approval gate is mandatory.
- Refactor in small, behavior-preserving steps; keep the build green between steps.

**NEVER:**
- Change product behavior, public APIs, or contracts as part of the restructure.
- Do a big-bang rewrite without an approved plan and a way to verify behavior is unchanged.
- Move files without updating references, namespaces, and tests.

## Workflow

### Phase 1 — Understand (read-only, delegated)

Launch `Explore` subagents **in parallel** to map the current architecture: modules/projects,
dependency direction, where concerns are mixed, coupling hotspots, and the existing folder/namespace
layout. Reconstruct how the system is organized today before redesigning it.

### Phase 2 — Design the target

Design the clean structure:

- **Separation of concerns** — clear layers/boundaries (domain, application, infrastructure, presentation).
- **Modularity** — cohesive modules with single responsibilities.
- **Decoupling** — depend on abstractions; invert dependencies toward the core.
- **Scalability & maintainability** — boundaries that allow independent change and growth.

For .NET solutions, follow the layered/DDD structure in `dotnet:dotnet-architecture`.
If the codebase is unfamiliar, run `senior-engineer-audit` first for a non-mutating assessment.

### Phase 3 — Plan (approval gate)

Present a structured report:

1. **New folder structure** — the target layout (tree), with what moves where.
2. **Clean architecture breakdown** — the layers/modules and their responsibilities and dependencies.
3. **Migration plan** — the ordered, behavior-preserving steps to get from current to target.
4. **Proposed changes** — concrete moves/edits with before/after sketches.

For a change of this size, capture the plan with `common:create-implementation-plan`.
**Wait for the user's approval before making any edit.**

### Phase 4 — Apply & verify

On approval, execute the migration in small steps:

- Move/restructure code, updating references, namespaces, imports, and tests as you go.
- Build and run the test suite after each meaningful step to confirm behavior is unchanged.
- If no build/test command is known, ask the user how to verify.
- Finish with an **explanation of the architectural improvements** and the verification result.

## Output Format

```
## New Folder Structure
<target tree>

## Clean Architecture Breakdown
<layers/modules, responsibilities, dependency direction>

## Migration Plan
<ordered, behavior-preserving steps>

## Proposed Changes
<moves/edits + before/after sketches>

## Architectural Improvements (after applying)
<what improved and why>
```

Wersje

W bazie nie ma innych skilli o nazwie clean-architecture-refactor.

Migawka bazy z 13.11.2026 · wersja paczki aee51b08a1e6 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90modular-architecture-refactor
    Planuje i wykonuje refaktoryzację architektury bez zmiany zachowania: moduły, rozdzielanie odpowiedzialności, cykle zależności i punkty rozszerzeń.
  • 100refactoring
    Zmienia strukturę kodu bez zmiany zachowania: wyodrębnia fragmenty, zmienia nazwy w wielu plikach, redukuje duplikaty i porządkuje architekturę.
  • 100senior-engineer-audit
    Analizuje obcy kod jak nowy inżynier: opisuje architekturę i przepływ danych, a potem wskazuje ryzyka, duplikaty i wąskie gardła.
  • 100acp-refactor
    Refaktoryzuje, czyści i upraszcza istniejący kod bez zmiany zachowania, w małych, odwracalnych krokach.
  • 100refactoring-workflow
    Poprawia strukturę istniejącego kodu bez zmiany zachowania w małych zweryfikowanych krokach przy zielonych testach, redukując duplikację i sprzężenia oraz przygotowując kod pod nową funkcję.
  • 100codebase-cleanup-refactor-clean
    Refaktoryzuje kod według zasad czystego kodu i SOLID, poprawiając jakość, utrzymywalność i wydajność istniejącego projektu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.