Skip to content
Skills Library
Programming · Analysis

architect

/architect

Analyze system architecture, module structure, API contracts, data models, and code patterns. Use when designing systems, reviewing module boundaries, evaluating API designs, analyzing data models, checking pattern conformance, tracing decisions, or reviewing frontend architecture. Triggers: "architecture", "module design", "API design", "data model", "boundaries", "patterns", "decisions", "frontend architecture".

Licence
MIT
Last repository change
14.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Analyze system architecture, module structure, API contracts, data models, and code patterns. Use when designing systems, reviewing module boundaries, evaluating API designs, analyzing data models, checking pattern conformance, tracing decisions, or reviewing frontend architecture. Triggers: "architecture", "module design", "API design", "data model", "boundaries", "patterns", "decisions", "frontend architecture".

Triggers from the description

architecturemodule designAPI designdata modelboundariespatternsdecisionsfrontend architecture

Arguments

/architect [--deep] module <name> | api <feature> | data-model <feature> | boundaries | patterns | decisions | frontend <feature>
Original author description

Analyze system architecture, module structure, API contracts, data models, and code patterns. Use when designing systems, reviewing module boundaries, evaluating API designs, analyzing data models, checking pattern conformance, tracing decisions, or reviewing frontend architecture. Triggers: "architecture", "module design", "API design", "data model", "boundaries", "patterns", "decisions", "frontend architecture".

How it works

  1. Context Discovery
  2. Arguments
  3. Mode Execution
  4. Output Rules
  5. File Persistence
  6. Deep Mode (--deep)
  7. Lane Discipline
  8. References
Original SKILL.md headings · 88 lines, 467 words
SKILL.md preview
---
name: architect
description: >
  Analyze system architecture, module structure, API contracts, data models, and code patterns.
  Use when designing systems, reviewing module boundaries, evaluating API designs, analyzing
  data models, checking pattern conformance, tracing decisions, or reviewing frontend architecture.
  Triggers: "architecture", "module design", "API design", "data model", "boundaries",
  "patterns", "decisions", "frontend architecture".
argument-hint: "[--deep] module <name> | api <feature> | data-model <feature> | boundaries | patterns | decisions | frontend <feature>"
allowed-tools: Read, Glob, Grep, Write
---

# System Architect

Analyze system architecture, module boundaries, API contracts, data models, and code patterns.

## Context Discovery

Run the shared context discovery protocol in [CONTEXT_DISCOVERY.md](../../references/CONTEXT_DISCOVERY.md). Execute all phases in order (use deep scan mode for Phase 7). Also glob for architecture-specific documents:

```
docs/adr/**/*.md, docs/architecture/**/*.md, docs/design/**/*.md
```

After standard discovery, perform architecture-specific scans from [TECH_STACK_DETECTION.md](../../references/TECH_STACK_DETECTION.md) § Architecture-Specific Scanning (framework detection, architecture patterns, database patterns).

## Arguments

Parse from `$ARGUMENTS`:

| Mode | Description |
|------|-------------|
| `module <name>` | Deep module structure analysis |
| `api <feature>` | API endpoint analysis and design guidance |
| `data-model <feature>` | Database schema and data model analysis |
| `boundaries` | Module boundary and coupling analysis |
| `patterns` | Pattern conformance check |
| `decisions` | ADR and decision traceability |
| `frontend <feature>` | Frontend architecture guidance |
| _(none)_ | Ask what the user needs architectural guidance on |

## Mode Execution

| Mode | Produces |
|------|----------|
| `module <name>` | Structure, domain model, API surface, dependencies, maturity, quality assessment, and prioritized recommendations |
| `api <feature>` | Endpoint design (method, path, DTOs, auth, pagination, errors) matching existing patterns |
| `data-model <feature>` | Schema design (tables, types, relationships, indexes, migrations) matching existing models |
| `boundaries` | Import graph, shared references, coupling analysis, boundary violations |
| `patterns` | Pattern catalog with codebase examples (layering, DTOs, events, testing) |
| `decisions` | Decision traceability table (decision, evidence, status) |
| `frontend <feature>` | Component hierarchy, data flow, state management, design system integration |

See [WORKFLOW.md](WORKFLOW.md) for detailed execution steps per mode.

## Output Rules

- **Conversational with optional file persistence** — analysis in chat, offer to save
- **Diagram-friendly** — use Mermaid diagrams when they clarify relationships
- **Pattern-consistent** — always reference existing codebase patterns
- **Practical** — recommendations should be implementable
- **Scoped** — answer the specific question; don't redesign the whole system

## File Persistence

After producing the analysis, ask the user:

> **Save this analysis to `{output_dir}/architecture/{filename}.md`?**

Where `{output_dir}` comes from `.arkhe.yaml` (default: `arkhe/roadmap`).

| Mode | Filename Pattern |
|------|-----------------|
| `module <name>` | `module-{name}.md` |
| `api <feature>` | `api-{feature-slug}.md` |
| `data-model <feature>` | `data-model-{feature-slug}.md` |
| `boundaries` | `boundary-analysis.md` |
| `patterns` | `pattern-catalog.md` |
| `decisions` | `decision-traceability.md` |
| `frontend <feature>` | `frontend-{feature-slug}.md` |

## Deep Mode (`--deep`)

When `$ARGUMENTS` contains `--deep`, run the full multi-agent pipeline with **Adversarial Review**. A red team agent actively tries to break the proposed architecture.

See [WORKFLOW.md](WORKFLOW.md) § Deep Pipeline for the 5-phase execution protocol.

**Patterns applied**: Pipeline, Confession, Adversarial Review, Confidence-Gated Completion.

## Lane Discipline

See the System Architect section of [LANE_DISCIPLINE.md](../../references/LANE_DISCIPLINE.md). Stay in your lane.

## References

- [WORKFLOW.md](WORKFLOW.md) — Detailed pattern analysis workflows
- [EXAMPLES.md](EXAMPLES.md) — Usage examples
- [TROUBLESHOOTING.md](TROUBLESHOOTING.md) — Common issues and fixes
Files in this package (4)
  • EXAMPLES.md 8 KB
  • SKILL.md 4 KB
  • TROUBLESHOOTING.md 3 KB
  • WORKFLOW.md 10 KB

Versions

RepositoryScoreLicence
This page · joaquimscosta/arkhe-claude-plugins100MIT
Aghasi-Sargsyan/architect-skill100MIT
RIJUDEVx/agent-skills100MIT
wonsukchoi/domain-experts100MIT
chhoumann/t3-pstack100MIT
kriscard/Skills100MIT
arjitj2/open-pstack100MIT
backnotprop/pstack100MIT
painhardcore/pstack100MIT

Database snapshot: 13.11.2026 · package version 243a9e41bc0c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90technical-architect-workflow
    Use when owning full-stack architecture, SDD design brainstorming, backend/frontend integration, service boundaries, data models, API contracts, runtime behavior, mainline implementation strategy, parallel decomposition, or Developer/Frontend Designer-code review as the Technical Architect.
  • 100architecture-design
    When the user needs to design or evaluate system architecture — service boundaries, data models, API contracts, infrastructure topology, database selection, or dependency analysis. Also activate for "design the system", "how should I architect this", "monolith vs microservices",…
  • 100design
    Design component architecture, REST API contracts, and data models (Pydantic schemas) before implementation. Use when planning how to build a feature, defining endpoints, or modeling data. Trigger on "design the architecture", "design the API", "data model", "how should I structure this feature".
  • 100architecture
    Apply software architecture best practices and design patterns. Use when designing systems, refactoring code, making architectural decisions, or reviewing code structure.
  • 90review-architecture
    Review code from a high-level system architecture perspective — SOLID principles, design patterns, module coupling, and API design. Use when auditing structural integrity, dependencies, or component boundaries. Invoked by /ac:review.
  • 100frontend-architecture
    Reference for designing frontend structure that stays maintainable as an application grows - feature-based vs layered organization, component architecture, module boundaries and dependency direction, shared code, routing, authentication and multi-role architecture, API contract…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.