20 skills · category

Architecture skills for Claude Code

Skills for shaping systems that survive their second year: design reviews with real numbers, domain-driven design, event-driven patterns with outboxes and sagas, ADRs, C4 diagrams, service boundaries, hexagonal and modular monoliths, multi-tenancy, rate limiting, idempotency and feature flags.

Download all 20 (.zip) Browse the list

Every architecture skill

Each card opens the full playbook, example prompts and install commands.

ADR Records

Decisions your team can still explain next year

Claude writes one ADR per decision, with measurable drivers, honest options including do-nothing, consequences that list the costs, and a way to confirm the decision holds. A bundled script numbers new records, links superseded ones in both directions, and lints the folder, so the decision log in your repo stays consistent as it grows.

adr-records 157 lines · 2 files

Backend for Frontend

Add a BFF or gateway only for a named problem

Claude starts by measuring calls per screen and latency before agreeing to a new layer, then splits duties cleanly: gateways take TLS, edge auth and rate limits, while a client-owned BFF aggregates and shapes data per screen. Aggregation runs in parallel under deadlines with explicit degraded fields, browser tokens stay server-side, and business rules stay in the services that own the data.

backend-for-frontend 169 lines

C4 Diagrams

Architecture diagrams as code that newcomers can read

Claude inventories the real system from compose files, infrastructure code and external API calls, then draws C4 context and container diagrams as code with one zoom level each. Every box names its technology and responsibility, every arrow states intent and protocol, and the sources live next to the code so they get updated in the same pull request.

c4-diagrams 193 lines

Cache Invalidation

Staleness budgets, closed races, no stampedes

Claude sets a staleness budget for each kind of cached data and picks invalidation from it: TTL only, delete after commit, versioned keys, or change-data-capture events. It closes the reader-writer race that leaves stale values in place until expiry, protects hot keys with single flight, early refresh and stale-while-revalidate, and adds hit ratio and staleness sampling so freshness is measured, not hoped for.

cache-invalidation 198 lines

Capacity Planning

Know which resource runs out first, and when

Claude turns business drivers into peak requests per second, takes per-instance capacity from a load test at the latency SLO instead of CPU guesses, and applies utilization targets plus zone-loss headroom. A bundled script projects instances, connections, writes, workers, storage and cost over months, flags the first resource to run out, and the plan lists actions with lead times and decision dates.

capacity-planning 174 lines · 2 files

CQRS and Event Sourcing

Event-source only what truly needs history

Claude first checks whether event sourcing is justified by audit, temporal queries or domain complexity, and recommends plain CQRS when it is not. When it is, it designs past-tense events with metadata, appends with expected version, folds aggregates with pure evolve and decide functions, and builds idempotent projections with gap-safe checkpoints that can be rebuilt side by side without downtime.

cqrs-event-sourcing 221 lines · 2 files

Data Partitioning

Pick shard keys from data, not from hope

Claude only recommends sharding after indexes, replicas, caching and native partitioning are ruled out, then picks the key from measured query patterns and runs a bundled simulator on real key frequencies to show skew, hot keys and how much data moves when a shard is added. It plans cross-shard queries, unique IDs and a rehearsed slot-by-slot resharding procedure before launch.

data-partitioning 196 lines · 2 files

Domain-Driven Design

Code boundaries that match how the business works

Claude starts with strategic DDD before any tactical patterns: it separates core from generic subdomains, finds bounded contexts where words change meaning, writes a glossary per context, and draws a context map with explicit integration patterns. Aggregates come last, kept small around real invariants, and Claude says plainly when CRUD is the better fit.

domain-driven-design 188 lines

Event-Driven Architecture

Events that survive duplicates, crashes and reordering

Claude designs event flows that stay correct under at-least-once delivery. State changes and their events commit together through a transactional outbox, consumers deduplicate with an inbox table, multi-step workflows become sagas with explicit compensations and timeouts, and event schemas evolve compatibly so a producer deploy never breaks a consumer.

event-driven-architecture 193 lines · 2 files

Feature Flags

Gradual rollouts, instant rollback, no flag graveyard

Claude adds each flag with a type, owner, expiry date and cleanup ticket, branches at a single point with a safe default, and buckets users deterministically so rollouts are sticky. Rollout plans name guardrail metrics and hold times, removal follows a code-first order, and a bundled audit script flags expired, unregistered and orphaned flags in CI.

feature-flags 170 lines · 2 files

Fitness Functions

Architecture rules that fail the build, not reviews

Claude turns architecture decisions into executable CI checks: dependency direction, module boundaries, cycle bans, complexity and size limits, bundle and latency budgets, and API breaking-change diffs. Existing violations are baselined instead of blocking the team, a bundled ratchet script fails on any regression and tightens the baseline on improvement, and every rule's message links the decision it protects.

fitness-functions 172 lines · 3 files

Hexagonal Architecture

Business logic that runs without a framework attached

Claude separates domain and use-case code from frameworks, ORMs and SDKs by defining ports in the application's own language and implementing them with adapters wired in one composition root. Use cases get millisecond tests with in-memory fakes, adapters get real integration tests, and dependency-cruiser, import-linter or ArchUnit keeps the rule from eroding.

hexagonal-architecture 212 lines

Idempotency and Retries

Retry anything without charging anyone twice

Claude makes every retried operation produce one effect: natural idempotence where it is cheap, idempotency keys with stored responses and in-progress locks elsewhere, and derived keys passed to payment and email providers. Retry loops get a retryable-error list, full-jitter backoff, a deadline and a single owning layer, so a short blip never becomes duplicate orders or a retry storm.

idempotency-retries 213 lines

Modular Monolith

Service-grade boundaries inside one deployable

Claude organizes a monolith into business modules that each expose one public API, keep internals and tables private, and talk through calls or in-process events. Boundaries are enforced in CI with the stack's native checker, existing violations are baselined so only new ones fail, and modules become extraction-ready without anyone rewriting the system.

modular-monolith 214 lines

Multi-Tenancy

No leaks between customers, no noisy neighbors

Claude picks a tenant isolation model per pricing tier, resolves the tenant once from a trusted claim, and carries that context through the database session, jobs, events, caches, storage and logs. Isolation is enforced by row-level security or physical separation that fails closed, noisy tenants are contained with quotas and fair queues, and every endpoint gets a cross-tenant leak test.

multi-tenancy 185 lines

Rate Limiting

Atomic limits, honest headers, clients that back off

Claude chooses the algorithm, key and enforcement layer for each goal, whether that is abuse at the edge, plan limits at the gateway or business rules in the app, and implements distributed limits as single atomic Redis scripts using server time. Rejections return 429 with Retry-After, limits roll out in shadow mode first, and fail-open or fail-closed is decided per limit.

rate-limiting 167 lines · 2 files

★ Editor's pick

Resilience Patterns

One slow dependency should never sink the service

Claude starts with a dependency failure matrix that says what users see when each dependency is slow or down, then implements it: timeouts derived from latency budgets with deadline propagation, retry budgets that cannot amplify incidents, per-dependency breakers and bulkheads, load shedding before collapse, and liveness probes that never check the database. Fault injection proves each behavior before it is called done.

resilience-patterns 190 lines · 2 files

Saga Transactions

Multi-service transactions that undo cleanly, without 2PC

Claude designs a distributed transaction as an ordered list of compensable, pivot and retryable steps, defaults to an orchestrated state machine with persisted state, and gives every step an idempotency key, timeout and retry bound. A bundled checker rejects specs with missing compensations or a misplaced pivot and prints the exact undo order for each failure point.

saga-transactions 236 lines · 3 files

Service Boundaries

Split services on evidence, not fashion

Claude weighs microservice proposals against concrete forces such as team count, deploy cadence, scaling, fault isolation and compliance, then backs the call with data: change coupling mined from git history, table ownership and synchronous call chains. The result is a keep, enforce, extract or merge recommendation with a step-by-step strangler plan.

service-boundaries 156 lines · 2 files

★ Editor's pick

System Design Review

Turn 'it scales' into numbers and ranked findings

Claude reviews a design doc the way a staff engineer would: it writes down the requirements and assumptions, runs back-of-envelope numbers for peak traffic, storage and fan-out, traces each hot path hop by hop, and walks failure modes per component. The result is a short, severity-ranked list of findings, each with the tradeoff and a concrete alternative.

system-design-review 177 lines · 2 files

Choosing Architecture skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with Resilience Patterns and System Design Review. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Install Claude Code Skills (5 Ways) and Personal vs Project Skills.

By technology: PostgreSQL skills

Install several

Install several at once

The installer accepts any number of skill names. This command installs all 20; add --project after -- to install into the current repository.

The installer is a 101-line POSIX shell script. It downloads each skill you name from claudeskills.page and unpacks it into your skills folder, nothing else: no sudo, no telemetry. Every skill page shows the full SKILL.md, so you can read what you install first. Read install.sh

curl -fsSL https://claudeskills.page/install.sh | sh -s -- …20 names

Architecture skills FAQ

How do I install every Architecture skill at once?

Download the bundle at https://claudeskills.page/downloads/category/architecture.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- adr-records backend-for-frontend c4-diagrams.

Will installing 20 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which Architecture skill should I start with?

Start with Resilience Patterns, System Design Review. They cover the most common requests in this category; add the rest as your work calls for them.