architecture
/architecture
Projektuje architekturę złożonych funkcji przed implementacją i pomaga przy decyzjach systemowych obejmujących wiele modułów.
- Autor
- hellblazer ↗
- Repozytorium
- nexus ↗
- Licencja
- AGPL-3.0
- Ostatnia zmiana repozytorium
- 26.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.
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
- Model Selection
- Code Navigation
- When This Skill Activates
- Pipeline Position
- Pre-Dispatch: Seed Link Context
- Agent Invocation
- Architecture Methodology
- Success Criteria
- Agent-Specific PRODUCE
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
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · hellblazer/nexus | 100 | AGPL-3.0 |
| jikig-ai/soleur | 100 | Apache-2.0 |
| Come-In-Labs/agent-skills | 100 | MIT |
| dedujeong/gemba | 100 | Apache-2.0 |
| workbench-soft/agent-skills | 100 | MIT |
| boshu2/agentops | 100 | Apache-2.0 |
| Kanevry/session-orchestrator | 100 | MIT |
| mcouthon/agents | 100 | MIT |
| FrancoStino/opencode-skills-collection | 100 | MIT |
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.