Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

design-patterns

/design-patterns

Pomaga wybrać sposób strukturyzacji kodu dla powtarzalnego problemu: które wzorce się opłacają, które rzadko i kiedy wzorzec jest stosowany bez potrzeby.

Licencja
MIT
Ostatnia zmiana repozytorium
24.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 24.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

Pomaga wybrać sposób strukturyzacji kodu dla powtarzalnego problemu: które wzorce się opłacają, które rzadko i kiedy wzorzec jest stosowany bez potrzeby.

Wyzwalacze z opisu

should i use a strategy pattern hereinheritance or compositionthis is over-abstractedevery new type means touching ten files
Oryginalny opis (EN)

Use when choosing how to structure code for a recurring problem. Covers the patterns that earn their keep, the ones that usually do not, and how to recognize when a pattern is being applied for its own sake. Trigger on "should i use a strategy pattern here", "inheritance or composition", "this is over-abstracted", "every new type means touching ten files". Do not use for untangling one overly complex module — see the simple-design skill.

Jak działa

  1. Purpose
  2. When to Use
  3. Capabilities
  4. Inputs
  5. Outputs
  6. Workflow
  7. Best Practices
  8. Examples
  9. Notes
Sekcje z nagłówków SKILL.md, w oryginale · 86 linii, 577 słów
Podgląd SKILL.md
---
name: design-patterns
description: Use when choosing how to structure code for a recurring problem. Covers the patterns that earn their keep, the ones that usually do not, and how to recognize when a pattern is being applied for its own sake. Trigger on "should i use a strategy pattern here", "inheritance or composition", "this is over-abstracted", "every new type means touching ten files". Do not use for untangling one overly complex module — see the simple-design skill.
metadata:
  category: development
  version: 1.0.0
  tags: [design-patterns, architecture, solid, abstraction]
---

# Design Patterns

## Purpose

Apply structural patterns as solutions to problems you actually have. A pattern applied prophylactically is just indirection with a formal name.

## When to Use

- A problem recurs and the current structure requires a change in many places each time.
- Choosing between inheritance, composition, and configuration.
- Reviewing code that is heavily abstracted and hard to follow.
- Designing an extension point for third parties.

## Capabilities

- Creational: factory, builder, dependency injection.
- Structural: adapter, facade, decorator, proxy.
- Behavioral: strategy, observer, command, state machine.
- Concurrency: producer-consumer, worker pool, circuit breaker.
- Recognizing pattern misuse: the singleton-as-global, the abstract factory of one.

## Inputs

- The problem being solved and how often it recurs.
- The axis of expected change — what varies, and what stays fixed.
- Who extends the code: you, your team, or external consumers.

## Outputs

- A structure with a named rationale.
- The specific change it makes cheap, stated explicitly.

## Workflow

1. **Name the axis of variation.** A pattern buys flexibility along exactly one axis, at the cost of indirection along all of them. If you cannot name the axis, do not apply a pattern.
2. **Count the instances.** One implementation needs no strategy interface. Two might. Three definitely does.
3. **Choose the lightest structure that works.** A function passed as a parameter is a strategy. It does not need a class hierarchy.
4. **Write it concretely first.** Then extract the pattern when the second case arrives — the shape of the abstraction will be obvious rather than guessed.
5. **Justify the indirection.** If a reader must open three files to answer "what happens when I call this", the pattern is costing more than it returns.

## Best Practices

- Composition over inheritance, nearly always. Inheritance couples you to the parent's internals forever.
- Strategy, adapter, and decorator earn their keep constantly. Abstract factory and visitor rarely do outside frameworks.
- A singleton is a global variable with better manners. Use dependency injection instead — it makes the dependency visible and the code testable.
- A state machine with explicit states and transitions beats a tangle of boolean flags every time.
- Circuit breakers, retries, and timeouts are patterns too, and they are more likely to save you than any of the Gang of Four.
- Two similar pieces of code are not necessarily duplication. Deduplicating things that merely look alike couples things that change for different reasons.

## Examples

**Explicit state machine instead of boolean soup:**

```python
# Before: state is implied by three booleans, and half the combinations are invalid.
if order.is_paid and not order.is_shipped and not order.is_cancelled:
    ship(order)

# After: states are enumerated, transitions are the only way to move.
class OrderState(Enum):
    PENDING = auto()
    PAID = auto()
    SHIPPED = auto()
    CANCELLED = auto()

TRANSITIONS: dict[OrderState, set[OrderState]] = {
    OrderState.PENDING:   {OrderState.PAID, OrderState.CANCELLED},
    OrderState.PAID:      {OrderState.SHIPPED, OrderState.CANCELLED},
    OrderState.SHIPPED:   set(),
    OrderState.CANCELLED: set(),
}

def transition(order: Order, to: OrderState) -> None:
    if to not in TRANSITIONS[order.state]:
        raise InvalidTransition(f"{order.state.name} -> {to.name}")
    order.state = to
```

Invalid states are now unrepresentable, and the legal transitions are readable in one place.

## Notes

- The dependency-inversion principle is about direction, not about interfaces. An interface with exactly one implementation, created only to "follow the principle", inverts nothing.
- Facades are the most under-used pattern in large codebases: a single, small entry point to a subsystem does more for comprehensibility than any amount of internal cleanliness.

Wersje

RepozytoriumWynikLicencja
Ta strona · nimadorostkar/Claude-Skills-collection100MIT
spencerbeggs/effected100MIT
spencerbeggs/effected100MIT
joeblackwaslike/agent-skills100MIT
krzysztofsurdy/code-virtuoso100MIT
andreibesleaga/gabbe100CC-BY-4.0
pantheon-org/tekhne100MIT
itzcull/software-skills100MIT
guilhermevozniak/refactor-pilot-framework100MIT

Migawka bazy z 13.11.2026 · wersja paczki dafd2d232309 (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

  • 100design-pattern-suggestor
    Poleca wzorce projektowe na podstawie opisu problemu, wymagań lub kodu: kreacyjne, strukturalne, behawioralne, architektoniczne i współbieżności, z analizą kompromisów.
  • 100go-design-patterns
    Podaje idiomatyczne wzorce projektowe w Go: opcje funkcyjne, builder, fabryka, strategia, łańcuch middleware, pub/sub i inne dopasowane do systemu typów.
  • 100write-design-pattern
    Pisze wpis katalogu wzorców projektowych: opisuje wzorzec i jego zastosowanie po refaktoryzacji albo na prośbę.
  • 100rs-patterns
    Pomaga wybrać wzorzec projektowy lub idiom w Rust: builder, newtype, strategię, visitor, Deref czy mem::take, z odradzaniem antywzorców.
  • 100design-pattern-implementation
    Przegląda użycie wzorców projektowych w bazie kodu, ich nadużycia i miejsca, gdzie wzorce by pomogły, przy ocenie architektury i nadmiernej inżynierii.

Uwagi i zgłoszenia

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