Przejdź do treści
Biblioteka skilli
Programowanie · Pisanie

architecture

/architecture

Dokumentuje architekturę w trybie tylko do odczytu: opisuje strukturę systemu, relacje komponentów i interfejsy oraz tworzy diagramy wysokiego poziomu.

Repozytorium
agents ↗
Licencja
MIT
Ostatnia zmiana repozytorium
25.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 25.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

Dokumentuje architekturę w trybie tylko do odczytu: opisuje strukturę systemu, relacje komponentów i interfejsy oraz tworzy diagramy wysokiego poziomu.

Wyzwalacze z opisu

use architecture modearchitecturesystem designhow is this structureddocument the systemcreate a diagramhigh-level overview
Oryginalny opis (EN)

Use when documenting architecture, understanding system structure, creating diagrams, or analyzing component relationships. Focuses on interfaces and high-level design. Triggers on: 'use architecture mode', 'architecture', 'system design', 'how is this structured', 'document the system', 'create a diagram', 'high-level overview'. Read-only mode.

Jak działa

  1. Core Constraint
  2. What to Focus On
  3. Anti-Patterns
  4. Analysis Framework
  5. Architecture Overview Format
  6. Mermaid Diagrams
  7. API Contract Format
Sekcje z nagłówków SKILL.md, w oryginale · 175 linii, 569 słów
Podgląd SKILL.md
---
name: architecture
description: "Use when documenting architecture, understanding system structure, creating diagrams, or analyzing component relationships. Focuses on interfaces and high-level design. Triggers on: 'use architecture mode', 'architecture', 'system design', 'how is this structured', 'document the system', 'create a diagram', 'high-level overview'. Read-only mode."
context: fork
allowed-tools: [Read, Grep, Glob, LSP]
---

# Architecture Mode

High-level design and system understanding.

## Core Constraint

> "Interfaces in; interfaces out. Data in; data out. Major flows, contracts, behaviors, and failure modes only."

If you find yourself describing implementation details, STOP. Zoom out.

## What to Focus On

✅ **Include**:

- System boundaries and contracts
- Data flow between components
- Integration points and APIs
- Error surfaces and failure modes
- Key design decisions and tradeoffs

❌ **Never Include**:

- Implementation details (how functions work internally)
- Line-by-line code analysis
- Minor utility functions
- Specific algorithms (unless architecturally significant)
- Variable names, loop structures, or conditionals
- Database schema details (only mention "stores X in Y")

## Anti-Patterns

| ❌ Don't Do This                        | ✅ Do This Instead                       |
| --------------------------------------- | ---------------------------------------- |
| "The function iterates over items..."   | "Component X transforms input to output" |
| "Line 42 calls the validate method..."  | "Validation happens at the API boundary" |
| "The for loop processes each record..." | "Records flow from A → B → C"            |
| "This uses a HashMap with..."           | "State is cached in memory"              |

## Analysis Framework

### 1. Component Identification

- What are the major components/modules?
- What is each component's single responsibility?
- How are they organized (layers, services, etc.)?

### 2. Interface Analysis

- What are the public APIs?
- What data structures cross boundaries?
- What are the contracts between components?

### 3. Data Flow

- How does data enter the system?
- How does it transform as it moves?
- Where is state stored?

### 4. Integration Points

- What external systems are connected?
- What protocols/formats are used?
- What are the failure modes?

### 5. Quality Attributes

- How is reliability achieved?
- How does it scale?
- What security measures exist?

## Architecture Overview Format

```markdown
## Architecture Overview

### Purpose

[What this system does in 1-2 sentences]

### Components

| Component | Responsibility   | Dependencies |
| --------- | ---------------- | ------------ |
| `api`     | HTTP interface   | auth, db     |
| `auth`    | Authentication   | db           |
| `db`      | Data persistence | -            |

### Data Flow

[Mermaid diagram - see below]

### Key Decisions

| Decision | Rationale | Tradeoffs   |
| -------- | --------- | ----------- |
| [choice] | [why]     | [pros/cons] |
```

## Mermaid Diagrams

### Component Diagram

```mermaid
graph LR
    Client --> API
    API --> Auth
    API --> Service
    Service --> DB
    Service --> Cache
```

### Sequence Diagram

```mermaid
sequenceDiagram
    participant C as Client
    participant A as API
    participant S as Service
    participant D as Database

    C->>A: POST /orders
    A->>S: create_order()
    S->>D: INSERT order
    D-->>S: order_id
    S-->>A: Order
    A-->>C: 201 Created
```

## API Contract Format

````markdown
## API: /orders

### POST /orders

Create a new order.

**Request**:

```json
{
  "items": [{ "sku": "ABC", "qty": 2 }],
  "customer_id": "cust_123"
}
```
````

**Response** (201):

```json
{
  "order_id": "ord_456",
  "status": "pending",
  "total": 49.99
}
```

**Errors**:

- `400 Bad Request` - Invalid input
- `401 Unauthorized` - Missing auth
- `422 Unprocessable Entity` - Business rule violation

```

## Guidelines

- Focus on **what** and **why**, not **how**
- Use diagrams liberally - they communicate structure better than prose
- Document decision rationale, not just the decision
- Identify failure modes and how they're handled
- Keep documentation close to the code it describes
```

Wersje

RepozytoriumWynikLicencja
Ta strona · mcouthon/agents100MIT
jikig-ai/soleur100Apache-2.0
Come-In-Labs/agent-skills100MIT
dedujeong/gemba100Apache-2.0
workbench-soft/agent-skills100MIT
boshu2/agentops100Apache-2.0
Kanevry/session-orchestrator100MIT
FrancoStino/opencode-skills-collection100MIT
Reprograme/redevkit100MIT

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

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

Pobrania w ostatnich 30 dniach: 1 · ranking

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

Podobne skille

  • 100architecture-diagram
    Generuje diagram architektury w Mermaid pokazujący relacje komponentów wysokiego poziomu, np. powiązania pluginów lub modułów.
  • 100architecture-designer
    Projektuje architekturę wysokiego poziomu, tworzy diagramy i ADR, ocenia kompromisy technologiczne, planuje skalowalność oraz przegląda istniejące projekty.
  • 100atlas-map
    Mapuje architekturę systemu: czyta kod, identyfikuje usługi i połączenia i tworzy mapę na poziomie C4 jako diagramy Mermaid z opisami komponentów.
  • 100c4-architecture
    Generuje dokumentację architektury z diagramów C4 w Mermaid: kontekst, kontenery, komponenty i wdrożenie systemu.
  • 10001-high-level-design
    Tworzy architekturę systemu wysokiego poziomu z granicami, komponentami, krytycznymi przepływami, topologią wdrożenia i ADR na podstawie zatwierdzonych wymagań albo odtwarza projekt as-built z istniejącego kodu.
  • 100c4-model
    Generuje dokumentację architektury w modelu C4 na poziomach kodu, komponentów, kontenerów i kontekstu, z diagramami oraz opisem granic komponentów i wdrożenia.

Uwagi i zgłoszenia

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