Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

architecture

/architecture

Projektuje architekturę złożonych funkcji przed implementacją i pomaga przy decyzjach systemowych obejmujących wiele modułów.

Repozytorium
nexus ↗
Licencja
AGPL-3.0
Ostatnia zmiana repozytorium
26.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 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

Co robi i kiedy

Projektuje architekturę złożonych funkcji przed implementacją i pomaga przy decyzjach systemowych obejmujących wiele modułów.

Oryginalny opis (EN)

Use when complex features need architectural design before implementation, or when system design decisions span multiple modules

Jak działa

  1. Model Selection
  2. Code Navigation
  3. When This Skill Activates
  4. Pipeline Position
  5. Pre-Dispatch: Seed Link Context
  6. Agent Invocation
  7. Architecture Methodology
  8. Success Criteria
  9. Agent-Specific PRODUCE
Sekcje z nagłówków SKILL.md, w oryginale · 118 linii, 719 słów
Podgląd SKILL.md
---
name: architecture
description: Use when complex features need architectural design before implementation, or when system design decisions span multiple modules
effort: high
---

# Architecture Skill

Delegates to the **architect-planner** agent.

## Model Selection

Default: **opus** (`conexus/agents/architect-planner.md` pins `model: opus` in its
frontmatter, and an agent's own declaration beats the session default, so
omitting `model` on the Agent tool gets opus). Pass `model: sonnet`
explicitly for the cheap end of the table below:

| Task Shape | Model | When |
|-----------|-------|------|
| Single-module design, extension of existing pattern | sonnet (pass it) | Most architecture work |
| Multi-phase, novel architecture, or system-wide redesign | opus (default) | Greenfield, cross-cutting concerns |

## Code Navigation

**REQUIRED SUB-SKILL:** Use **/conexus:serena-code-nav** for symbol-level architecture discovery. Combine with `nx search --hybrid` for semantic discovery — Serena for precision, nx search for conceptual queries.

`--hybrid` and `--lexical` are different flags doing different jobs, and the names invite conflating them. `--hybrid` RE-RANKS vector results by git frecency for code corpora; it never changes which rows come back. `--lexical` ADDS hits from the engine's exact-text indexes (full-text + trigram) to the vector results; it changes which rows come back and is what finds a rare identifier a semantic search misses (measured 0.167 -> 0.698 precision@10 on rare tokens, RDR-217). Reach for `--lexical` when you know the token; `--hybrid` when you want recently-touched code ranked higher.

- **Map system structure**: `get_symbols_overview` for class/interface inventories without reading files
- **Find architectural patterns**: `find_referencing_symbols` to trace abstraction usage across the codebase
- **Understand module boundaries**: `find_referencing_symbols` to track cross-module calls
- **Interface analysis**: `type_hierarchy` to see full implementation tree
- **Serena for precision, nx search for semantic discovery**

### Architecture Discovery Workflow
```
1. nx search --corpus code --hybrid (30-50 results) for semantic discovery
2. get_symbols_overview to map key classes in discovered files
3. type_hierarchy to trace abstraction patterns
4. find_referencing_symbols to understand cross-module usage
5. Synthesize findings with `mcp__plugin_conexus_sequential-thinking__sequentialthinking`
6. Design architecture with clear boundaries
```

## When This Skill Activates

- Before implementing complex features requiring architecture design
- When planning multi-step implementations
- Before major refactoring efforts
- When system design decisions are needed
- When establishing module boundaries or interfaces

## Pipeline Position

```
strategic-planner -> nx_plan_audit -> architect-planner -> developer
```

## Pre-Dispatch: Seed Link Context

Before dispatching the architect-planner agent, seed T1 scratch with link targets so the auto-linker can create catalog links when the agent stores findings:

1. If the task references an RDR (pattern `RDR-\d+`) or a known document, resolve it: `mcp__plugin_conexus_nexus-catalog__search(query="RDR-NNN or document title")`
2. Check T1 scratch for `rdr-planning-context`
3. Write link context to scratch:
   ```
   mcp__plugin_conexus_nexus__scratch(action="put", content='{"targets": [{"tumbler": "<resolved-tumbler>", "link_type": "relates"}], "source_agent": "architect-planner"}', tags="link-context")
   ```
4. If no RDR/document reference found, skip seeding (the auto-linker handles empty context gracefully)

## Agent Invocation

Use the Agent tool to invoke **architect-planner**:

```markdown
## Relay: architect-planner

**Task**: [what needs to be done]
**Bead**: [ID] or 'none'

### Input Artifacts
- Files: [relevant files]

### Deliverable
Architecture design with execution plan

### Quality Criteria
- [ ] Component boundaries clearly defined
- [ ] Interfaces specified
- [ ] Execution plan created with beads
```

For full relay structure and optional fields, see [RELAY_TEMPLATE.md](../../resources/agent-shared/RELAY_TEMPLATE.md).

## Architecture Methodology

The architect-planner uses `nx search --corpus code --hybrid` for discovery (30-50 results), then `mcp__plugin_conexus_sequential-thinking__sequentialthinking`:
1. Understand system architecture and integration patterns
2. Synthesize findings into architectural approach
3. Define component boundaries and interfaces
4. Create execution plan with beads
5. Identify risks and mitigations

## Success Criteria

- [ ] All requirements addressed in design
- [ ] Component boundaries clearly defined
- [ ] Interfaces specified
- [ ] Execution plan created with beads
- [ ] Beads created for trackable work
- [ ] Risks identified with mitigations
- [ ] Ready for `mcp__plugin_conexus_nexus__nx_plan_audit` validation (RDR-080)

## Agent-Specific PRODUCE

- **Architecture Designs**: Store in T3 via store_put tool: content="# Architecture: {component}\n{design}", collection="<subject>", title="architecture-{project}-{component}", tags="architecture,design"
- **Execution Plans**: Store in T2 memory via memory_put tool: content="plan", project="{project}", title="plan-{component}.md" — omit `ttl` (permanent); a plan future sessions must find is a record of record, not a row that should expire
- **Design Decisions**: Store in T3 via store_put tool: content="# Decision: {topic}\n{rationale}", collection="<subject>", title="decision-architect-{topic}", tags="decision,architecture"
- **Beads**: Epic → Phase → Task hierarchy with `bd dep add` for dependencies
- **Design Notes**: Use T1 scratch for working notes during architecture analysis:
  - scratch tool: action="put", content="Design consideration: {note}", tags="architecture,design"
  - scratch_manage tool: action="flag", entry_id="<id>", project="{project}", title="architecture-notes.md"

Wersje

RepozytoriumWynikLicencja
Ta strona · hellblazer/nexus100AGPL-3.0
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
mcouthon/agents100MIT
FrancoStino/opencode-skills-collection100MIT

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

  • 100adr
    Prowadzi strukturalne podejmowanie decyzji architektonicznych dla złożonych funkcji obejmujących wiele warstw (baza, API, frontend, bezpieczeństwo), z drzewem decyzji, zanim zacznie się kodowanie.
  • 100feature-dev
    Prowadzi pracę nad funkcją krok po kroku: eksploracja kodu, doprecyzowanie wymagań, projekt architektury, implementacja i przegląd, dla zmian obejmujących wiele modułów.
  • 100design-architecture
    Projektuje architekturę systemu, podejmuje decyzje architektoniczne i przekłada PRD na projekt techniczny.
  • 100plan-create
    Proponuje fazowy plan wdrożenia z bramkami przed rozpoczęciem pracy, także proaktywnie przy złożonych zadaniach obejmujących wiele plików, nowe funkcje lub zmiany architektury.
  • 100design
    Projektuje architekturę komponentów, kontrakty REST API i modele danych (schematy Pydantic) przed implementacją.
  • 100claude-plan
    Prosi Claude Code o plan implementacji przed pisaniem kodu: numerowane kroki ze ścieżkami plików i interfejsami dla złożonych zadań obejmujących wiele plików lub niejasne wymagania.

Uwagi i zgłoszenia

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