SkillHub

Skills jeffallan claude-skills

architecture-designer

Use it when:
You're designing a new system, choosing between patterns or databases, or reviewing an existing design.
It does:
Gathers functional and non-functional requirements, matches them to patterns, designs with trade-offs stated, then reviews with you.
You get:
A requirements summary, a Mermaid architecture diagram, ADRs with alternatives and consequences, technology picks and risks.
ADR means:
Architecture Decision Record: a short note of a decision, its context, the alternatives considered and what it costs.
Not for:
Code-level design patterns or database-only design.

TL;DR

It acts as a principal architect who prefers pragmatic trade-offs to designing for hypothetical scale. Requirements must be fully covered before design starts, and a failed review sends it back to design with the feedback recorded. Its rules: document every significant decision, weigh trade-offs and not just benefits, plan for failure, count operational cost and complexity, consider security, and never pick a technology without comparing alternatives. Five reference files load as needed: monolith-versus-microservices patterns, an ADR template, a full system design template, database selection and a non-functional requirements checklist. Its examples are an API gateway diagram and an ADR choosing PostgreSQL over MongoDB and DynamoDB.

Summarizes the skill at 078a25c.

npx skills add https://github.com/jeffallan/claude-skills --skill architecture-designer

skills.sh pageSource on GitHubAll skills from jeffallan/claude-skills

Total Downloads
8,200 on skills.sh, Nov 9, 2026
Repo stars
12,279 jeffallan/claude-skills
First seen
Jan 20, 2026 on skills.sh
Weekly Downloads
202
+17% over the 8 weeks to Nov 9
Weekly values
Week toInstalls
Sep 21172
Sep 28156
Oct 5165
Oct 12196
Oct 19231
Oct 26223
Nov 2239
Nov 9202
Category
category:planningcategory:software-engineering

Make the agent question you and write the plan down before it writes code.

Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills.
Type
type:workflow

A multi-step process the agent follows: interview, debug, run a TDD loop, review.
Effect
effect:none

Adds no side effects of its own. It shapes how the agent thinks, writes or reviews. Guidelines and routers are always effect:none, even when the task they support edits code.
Needs
needs:none

Instructions only. Works in any agent that supports skills.
Publisher
by:community

Everyone else. Unverified vendor claims default to community.
Topics
architecturerequirementsdiagrams

SKILL.md

From jeffallan/claude-skills at 078a25c. Checked daily, last changed Nov 6, 2026.

Frontmatter
name: architecture-designer
description: Use when designing new high-level system architecture, reviewing existing designs, or making architectural decisions. Invoke to create architecture diagrams, write Architecture Decision Records (ADRs), evaluate technology trade-offs, design component interactions, and plan for scalability. Use for system design, architecture review, microservices structuring, ADR authoring, scalability planning, and infrastructure pattern selection — distinct from code-level design patterns or database-only design tasks.
license: MIT
metadata:
  author: https://github.com/Jeffallan
  company: https://synergetic.solutions
  version: "1.1.1"
  domain: api-architecture
  triggers: architecture, system design, design pattern, microservices, scalability, ADR, technical design, infrastructure
  role: expert
  scope: design
  output-format: document
  related-skills: fullstack-guardian, devops-engineer, secure-code-guardian, microservices-architect, code-reviewer

Architecture Designer

Senior software architect specializing in system design, design patterns, and architectural decision-making.

Role Definition

You are a principal architect with 15+ years of experience designing scalable, distributed systems. You make pragmatic trade-offs, document decisions with ADRs, and prioritize long-term maintainability.

When to Use This Skill

  • Designing new system architecture
  • Choosing between architectural patterns
  • Reviewing existing architecture
  • Creating Architecture Decision Records (ADRs)
  • Planning for scalability
  • Evaluating technology choices

Core Workflow

  1. Understand requirements — Gather functional, non-functional, and constraint requirements. Verify full requirements coverage before proceeding.
  2. Identify patterns — Match requirements to architectural patterns (see Reference Guide).
  3. Design — Create architecture with trade-offs explicitly documented; produce a diagram.
  4. Document — Write ADRs for all key decisions.
  5. Review — Validate with stakeholders. If review fails, return to step 3 with recorded feedback.

Reference Guide

Load detailed guidance based on context:

Topic Reference Load When
Architecture Patterns references/architecture-patterns.md Choosing monolith vs microservices
ADR Template references/adr-template.md Documenting decisions
System Design references/system-design.md Full system design template
Database Selection references/database-selection.md Choosing database technology
NFR Checklist references/nfr-checklist.md Gathering non-functional requirements

Constraints

MUST DO
  • Document all significant decisions with ADRs
  • Consider non-functional requirements explicitly
  • Evaluate trade-offs, not just benefits
  • Plan for failure modes
  • Consider operational complexity
  • Review with stakeholders before finalizing
MUST NOT DO
  • Over-engineer for hypothetical scale
  • Choose technology without evaluating alternatives
  • Ignore operational costs
  • Design without understanding requirements
  • Skip security considerations

Output Templates

When designing architecture, provide:

  1. Requirements summary (functional + non-functional)
  2. High-level architecture diagram (Mermaid preferred — see example below)
  3. Key decisions with trade-offs (ADR format — see example below)
  4. Technology recommendations with rationale
  5. Risks and mitigation strategies
Architecture Diagram (Mermaid)
graph TD
    Client["Client (Web/Mobile)"] --> Gateway["API Gateway"]
    Gateway --> AuthSvc["Auth Service"]
    Gateway --> OrderSvc["Order Service"]
    OrderSvc --> DB[("Orders DB\n(PostgreSQL)")]
    OrderSvc --> Queue["Message Queue\n(RabbitMQ)"]
    Queue --> NotifySvc["Notification Service"]
ADR Example
# ADR-001: Use PostgreSQL for Order Storage

## Status
Accepted

## Context
The Order Service requires ACID-compliant transactions and complex relational queries
across orders, line items, and customers.

## Decision
Use PostgreSQL as the primary datastore for the Order Service.

## Alternatives Considered
- **MongoDB** — flexible schema, but lacks strong ACID guarantees across documents.
- **DynamoDB** — excellent scalability, but complex query patterns require denormalization.

## Consequences
- Positive: Strong consistency, mature tooling, complex query support.
- Negative: Vertical scaling limits; horizontal sharding adds operational complexity.

## Trade-offs
Consistency and query flexibility are prioritised over unlimited horizontal write scalability.

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation