Skip to content
Skills Library
Programming · Planning

architect

/architect

Design system architecture and component interfaces. Use for architectural decisions.

Repository
dotfiles ↗
Licence
MIT
Last repository change
10.10.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.10.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

Design system architecture and component interfaces. Use for architectural decisions.

Original author description

Design system architecture and component interfaces. Use for architectural decisions.

How it works

  1. When to Use
  2. Design Process
  3. Architecture Patterns
  4. Decision Framework
  5. Key Principles
  6. Scalability Checklist
  7. Examples
Original SKILL.md headings · 131 lines, 394 words
SKILL.md preview
---
name: architect
description: Design system architecture and component interfaces. Use for architectural decisions.
---

# System Architecture

Design scalable, maintainable system architectures.

## When to Use

- Major architectural decisions
- System design discussions
- Evaluating trade-offs
- Planning large refactors
- Reviewing system structure

## Design Process

1. **Understand** - Clarify requirements and constraints
2. **Identify** - Define components and boundaries
3. **Design** - Create architecture with trade-offs
4. **Validate** - Check against requirements
5. **Document** - Record decisions and rationale

## Architecture Patterns

### Layered Architecture

```
┌─────────────────────────────┐
│      Presentation Layer     │  UI, API endpoints
├─────────────────────────────┤
│       Business Layer        │  Domain logic, services
├─────────────────────────────┤
│      Persistence Layer      │  Repositories, DAOs
├─────────────────────────────┤
│        Data Layer           │  Database, cache
└─────────────────────────────┘
```

### Microservices

```
┌─────────┐  ┌─────────┐  ┌─────────┐
│ User    │  │ Order   │  │ Payment │
│ Service │  │ Service │  │ Service │
└────┬────┘  └────┬────┘  └────┬────┘
     │            │            │
     └────────────┼────────────┘
                  │
           ┌──────┴──────┐
           │ Message Bus │
           └─────────────┘
```

### Event-Driven

```
Producer → Event Bus → Consumer(s)
              │
              ├→ Service A
              ├→ Service B
              └→ Analytics
```

## Decision Framework

### Trade-off Analysis

| Aspect         | Option A | Option B   |
| -------------- | -------- | ---------- |
| Complexity     | Low      | High       |
| Scalability    | Limited  | Horizontal |
| Cost           | $        | $$$        |
| Time to market | Fast     | Slow       |
| Maintenance    | Easy     | Complex    |

### ADR Template

```markdown
# ADR-001: [Decision Title]

## Status

Accepted | Proposed | Deprecated

## Context

[Why we need to make this decision]

## Decision

[What we decided]

## Consequences

### Positive

- [Benefit 1]

### Negative

- [Trade-off 1]

### Risks

- [Risk 1]
```

## Key Principles

- **Separation of Concerns** - Each component has one responsibility
- **Loose Coupling** - Minimize dependencies between components
- **High Cohesion** - Related functionality grouped together
- **YAGNI** - Don't build for hypothetical requirements
- **Fail Fast** - Detect and report errors immediately

## Scalability Checklist

- [ ] Stateless services (session in Redis/DB)
- [ ] Horizontal scaling capability
- [ ] Database read replicas
- [ ] Caching layer (Redis, CDN)
- [ ] Async processing for heavy tasks
- [ ] Rate limiting and circuit breakers

## Examples

**Input:** "Design a notification system"
**Action:** Define channels, queue architecture, delivery guarantees, scaling strategy

**Input:** "Should we use microservices?"
**Action:** Analyze team size, complexity, scaling needs, recommend with trade-offs

Versions

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

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 571e76d08eac (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

  • 100architecture
    Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
  • 100architecture
    Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
  • 100architecture
    Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
  • 100system-architect
    High-level system architecture, domain modeling, bounded contexts, explicit interfaces, and ADR records. Use when designing systems or establishing module boundaries.
  • 100unity-architect
    Use when designing Unity architecture, creating component hierarchies, defining interfaces, or generating test stubs and Mermaid diagrams for Unity projects
  • 100engineering-software-architect
    Use when Codex should act as the Software Architect specialist from Agency Agents. Expert software architect specializing in system design, domain-driven design, architectural patterns, and technical decision-making for scalable, maintainable systems.

Feedback and reports

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