New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Architecture Pattern Selector

by alirezarezvani in alirezarezvani/claude-cto-team

Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints.

MITAuto-check passedBackend & APIs

Install Architecture Pattern Selector

skills CLI
$ npx skills add alirezarezvani/claude-cto-team --skill architecture-pattern-selector -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install alirezarezvani/claude-cto-team architecture-pattern-selector --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/alirezarezvani/claude-cto-team.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/architecture-pattern-selector .claude/skills/architecture-pattern-selector && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
architecture-pattern-selector
GitHub stars
117
Token cost
~1.6k tokens
SKILL.md length
572 words
Files
3
Skills in repo
12
Repo updated
First seen
Licence
MIT

At a glance

Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints.

  • Works in 9 steps: Monolith → Modular Monolith → Microservices → …
  • Cto-architect needs to select the right architectural approach for a new system
  • SKILL.md covers When to Use, Architecture Patterns, Selection Framework and Output Format, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Architecture Pattern Selector is an agent skill from alirezarezvani/claude-cto-team. Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints. Use when cto-architect needs to select the right architectural approach for a new system or migration.

Its SKILL.md is about 1.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `decision-matrix.md` and `pattern-comparison.md`).

It sits in Backend & APIs, covering Software architecture, Microservices and Serverless. The repository describes itself as: Your personal CTO Team for Claude Code . These Subagents will help you challenging yourself while you plan and execute. The licence is MIT.

When your agent uses it

  • Cto-architect needs to select the right architectural approach for a new system
  • Tasks that involve Software architecture
  • Tasks that involve Microservices

Example prompts

  • “/architecture-pattern-selector”

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. Monolith
  2. Modular Monolith
  3. Microservices
  4. Serverless
  5. Hybrid
  6. Assess Current State
  7. Evaluate Constraints
  8. Apply Decision Matrix
  9. Consider Migration Path

What it can do on your machine

Read from SKILL.md and the folder at commit a5bbb78. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Architecture Pattern Selector loads about 1.6k tokens when it runs. Until then it costs about 66 tokens; SKILL.md has 572 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~66
When it runs · the whole SKILL.md, loaded when a task matches
~1.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from alirezarezvani/claude-cto-team at commit a5bbb78, republished under its MIT licence (© alirezarezvani). 572 words, ~1,598 tokens.

Download SKILL.mdSave it as .claude/skills/architecture-pattern-selector/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
architecture-pattern-selector
description
Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints. Use when cto-architect needs to select the right architectural approach for a new system or migration.

Architecture Pattern Selector

Provides systematic framework for selecting the right architecture pattern based on real-world constraints rather than hype or resume-driven development.

When to Use

  • Designing a new system from scratch
  • Evaluating whether to migrate from monolith to microservices
  • Choosing between serverless vs container-based architecture
  • Assessing if current architecture matches actual needs

Architecture Patterns

1. Monolith

Best for: Early-stage products, small teams, rapid iteration

Characteristics:

  • Single deployable unit
  • Shared database
  • Simple deployment and debugging
  • Fastest time to market

Choose when:

  • Team < 10 engineers
  • < 100K users
  • Product-market fit not yet proven
  • Need to iterate quickly on features
  • Limited DevOps expertise

Avoid when:

  • Different components need independent scaling
  • Multiple teams need to deploy independently
  • Parts of system have very different reliability requirements
2. Modular Monolith

Best for: Growing products that need structure without microservices complexity

Characteristics:

  • Single deployable unit with clear module boundaries
  • Modules communicate through defined interfaces
  • Can evolve to microservices later
  • Best of both worlds for mid-size teams

Choose when:

  • Team 10-30 engineers
  • 100K-1M users
  • Need better code organization
  • Want microservices benefits without operational overhead
  • Planning future extraction to services

Avoid when:

  • Need independent deployment per module
  • Modules have fundamentally different scaling requirements
  • Already have microservices expertise and infrastructure
3. Microservices

Best for: Large organizations with mature DevOps practices

Characteristics:

  • Independent deployable services
  • Service-specific databases
  • Complex operational requirements
  • High organizational overhead

Choose when:

  • Team > 30 engineers with multiple squads

  • 1M users with varying load patterns

  • Different services need different scaling strategies
  • Strong DevOps/Platform team
  • Clear bounded contexts

Avoid when:

  • Team lacks Kubernetes/container orchestration experience
  • No dedicated platform/DevOps team
  • Bounded contexts are unclear
  • Chasing microservices for resume value
4. Serverless

Best for: Event-driven workloads, variable traffic, cost optimization

Characteristics:

  • Pay-per-execution pricing
  • Auto-scaling to zero
  • Vendor lock-in concerns
  • Cold start latency

Choose when:

  • Highly variable or spiky traffic
  • Event-driven processing (webhooks, queues)
  • Cost-sensitive with unpredictable load
  • Simple request-response patterns
  • Limited DevOps capacity

Avoid when:

  • Consistent high-volume traffic (cost inefficient)
  • Low-latency requirements (< 100ms consistently)
  • Long-running processes
  • Complex stateful workflows
Show full SKILL.md (246 more words)Show less
5. Hybrid

Best for: Complex systems with varied requirements

Characteristics:

  • Mix of patterns for different components
  • Monolith core with serverless functions
  • Microservices for specific bounded contexts

Choose when:

  • Different parts of system have different characteristics
  • Migrating incrementally from monolith
  • Some components need independent scaling
  • Event-driven workflows alongside synchronous APIs

Selection Framework

Step 1: Assess Current State
Team Size:        [ ] < 10   [ ] 10-30   [ ] 30-100   [ ] > 100
User Scale:       [ ] < 100K [ ] 100K-1M [ ] 1M-10M   [ ] > 10M
DevOps Maturity:  [ ] None   [ ] Basic   [ ] Intermediate [ ] Advanced
Deployment Freq:  [ ] Monthly [ ] Weekly [ ] Daily    [ ] Multiple/day
Step 2: Evaluate Constraints
ConstraintImpact on Pattern Choice
Time to marketFavors monolith
Team autonomyFavors microservices
Cost sensitivityFavors serverless or monolith
Latency requirementsDisfavors serverless
Compliance/securityMay require isolation (microservices)
Step 3: Apply Decision Matrix

See decision-matrix.md for the scoring framework.

Step 4: Consider Migration Path

Every architecture should have a migration path:

  • Monolith → Modular Monolith → Microservices
  • Monolith → Hybrid (extract specific services)
  • Serverless → Containers (when scale justifies)

Output Format

When recommending an architecture pattern, provide:

markdown
## Architecture Recommendation

### Recommended Pattern: [Pattern Name]
**Confidence**: High / Medium / Low

### Why This Pattern
[2-3 specific reasons based on constraints]

### Trade-offs Accepted
- [Trade-off 1 and why it's acceptable]
- [Trade-off 2 and why it's acceptable]

### Migration Path
- **Current**: [Current state]
- **Phase 1**: [Near-term architecture]
- **Phase 2**: [If/when to evolve]
- **Trigger**: [What would cause migration to next phase]

### Patterns Rejected
| Pattern | Reason Not Selected |
|---------|---------------------|
| [Pattern] | [Specific reason] |

### Implementation Considerations
- [Key consideration 1]
- [Key consideration 2]
- [Key consideration 3]

Anti-Patterns to Avoid

Resume-Driven Architecture

Choosing microservices because it looks good on resumes, not because the problem requires it.

Red flag: "We should use microservices because that's what Netflix uses." Reality check: You're not Netflix. What's your actual scale and team size?

Premature Distribution

Distributing a system before understanding the domain boundaries.

Red flag: "Let's start with microservices from day one." Reality check: You'll draw the wrong boundaries. Start monolith, extract when clear.

Complexity Worship

Equating complexity with sophistication.

Red flag: "Our architecture needs to be enterprise-grade." Reality check: Simple architectures that work beat complex ones that don't.

References

© alirezarezvani, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in skills/architecture-pattern-selector of alirezarezvani/claude-cto-team.

  • SKILL.md
  • decision-matrix.md
  • pattern-comparison.md

Open the folder on GitHubat commit a5bbb78

Compare with similar skills

Architecture Pattern Selector next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Architecture Pattern Selector compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Architecture Pattern Selector this skillalirezarezvani/claude-cto-team117—~1.6kAutomated safety check: PassMIT
Architecture Selectionrsmdt/the-startup551—~1.2kAutomated safety check: PassMIT
AWS Solution Architectalirezarezvani/claude-code-skill-factory8801 repos~3.7kAutomated safety check: PassMIT
Anth Architecture Variantsjeremylongshore/tons-of-skills-marketplace2.8k—~1.9kAutomated safety check: PassMIT
Software Architecture DesignaAAaqwq/AGI-Super-Team105—~2.8kAutomated safety check: PassMIT
AWS Serverless Edazxkane/aws-skills3674 repos~3.2kAutomated safety check: PassMIT

Similar skills

  • Architecture Selection

    rsmdt/the-startup

    System architecture patterns including monolith, microservices, event-driven, and serverless, with C4 modeling, scalability strategies, and technology selection criteria.

    551 GitHub stars~1.2k tokensUpdated 2 mo ago
    Backend & APIsAuto-check passed

  • AWS Solution Architect

    alirezarezvani/claude-code-skill-factory

    Expert AWS solution architecture for startups focusing on serverless, scalable, and cost-effective cloud infrastructure with modern DevOps practices and infrastructure-as-code

    880 GitHub starsUsed in 1 repo~3.7k tokens
    Backend & APIsAuto-check passed

  • Anth Architecture Variants

    jeremylongshore/tons-of-skills-marketplace

    Choose and implement Claude API architecture patterns for different scales: serverless, microservice, event-driven, and edge deployment.

    2.8k GitHub stars~1.9k tokensUpdated today
    Backend & APIsAuto-check passed

  • Software Architecture Design

    aAAaqwq/AGI-Super-Team

    Designs system structure across monolith/microservices/serverless.

    105 GitHub stars~2.8k tokensUpdated 10 days ago
    Backend & APIsAuto-check passed

  • AWS Serverless Eda

    zxkane/aws-skills

    AWS serverless and event-driven architecture expert based on Well-Architected Framework.

    367 GitHub starsUsed in 4 repos~3.2k tokens
    Backend & APIsAuto-check passed

  • NestJS Modular Monolith Architect

    tech-leads-club/agent-skills

    Designs scalable NestJS modular monoliths with domain-driven design, Clean Architecture layers and optional CQRS, defining bounded contexts and strict module boundaries.

    7k GitHub stars~3.9k tokensUpdated 17 days ago
    Backend & APIsAuto-check passed

More from alirezarezvani/claude-cto-team

All 12 skills in this repo

  • Antipattern Detector

    alirezarezvani/claude-cto-team

    Detect common technical and organizational anti-patterns in proposals, architectures, and plans.

    117 GitHub stars~2.1k tokensUpdated 9 mo ago
    Auto-check passed

  • Assumption Challenger

    alirezarezvani/claude-cto-team

    Identify and challenge implicit assumptions in plans, proposals, and technical decisions.

    117 GitHub stars~2.4k tokensUpdated 9 mo ago
    Auto-check passed

  • Cost Estimator

    alirezarezvani/claude-cto-team

    Infrastructure and development cost estimation for technical projects.

    117 GitHub stars~3k tokensUpdated 9 mo ago
    Auto-check passed

  • ML Cv Specialist

    alirezarezvani/claude-cto-team

    Deep expertise in ML/CV model selection, training pipelines, and inference architecture.

    117 GitHub stars~3.1k tokensUpdated 9 mo ago
    Auto-check passed

  • Request Analyzer

    alirezarezvani/claude-cto-team

    Analyze incoming user requests to detect intent, request type (design/validate/debug/document), complexity level, and identify vague requirements or buzzwords that need clarification.

    117 GitHub stars~1.3k tokensUpdated 9 mo ago
    Auto-check passed

  • Roadmap Generator

    alirezarezvani/claude-cto-team

    Generate phased implementation roadmaps with Epic/Story/Task breakdown, effort estimates, and validation checkpoints.

    117 GitHub stars~1.9k tokensUpdated 9 mo ago
    Auto-check passed

Categories

Questions about Architecture Pattern Selector

What does Architecture Pattern Selector do?

Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints. Architecture Pattern Selector is an agent skill from alirezarezvani/claude-cto-team. Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints.

When should I use Architecture Pattern Selector?

Architecture Pattern Selector fits situations like: cto-architect needs to select the right architectural approach for a new system; tasks that involve Software architecture; tasks that involve Microservices.

How do I install Architecture Pattern Selector in Claude Code?

Run `npx skills add alirezarezvani/claude-cto-team --skill architecture-pattern-selector -a claude-code`. Or copy the skill folder (skills/architecture-pattern-selector in alirezarezvani/claude-cto-team) into .claude/skills/architecture-pattern-selector in your project. Claude Code loads it when a task matches its description.

How do I install Architecture Pattern Selector in Codex?

Run `npx skills add alirezarezvani/claude-cto-team --skill architecture-pattern-selector -a codex`. Or copy the skill folder (skills/architecture-pattern-selector in alirezarezvani/claude-cto-team) into .agents/skills/architecture-pattern-selector in your project. Codex loads it when a task matches its description.

Can I use Architecture Pattern Selector in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add alirezarezvani/claude-cto-team --skill architecture-pattern-selector -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/architecture-pattern-selector, .gemini/skills/architecture-pattern-selector, .github/skills/architecture-pattern-selector and .opencode/skills/architecture-pattern-selector in your project.

What does Architecture Pattern Selector need to run?

SKILL.md names no scripts, command-line tools or credentials: Architecture Pattern Selector is instructions for the agent only.

Does Architecture Pattern Selector access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Architecture Pattern Selector safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Architecture Pattern Selector use?

Architecture Pattern Selector is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Architecture Pattern Selector use?

About 1.6k tokens (SKILL.md is roughly 6.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Architecture Pattern Selector?

Skills that share tags, products or a category with Architecture Pattern Selector: Architecture Selection (rsmdt/the-startup, 551 stars), AWS Solution Architect (alirezarezvani/claude-code-skill-factory, 880 stars), Anth Architecture Variants (jeremylongshore/tons-of-skills-marketplace, 2.8k stars) and Software Architecture Design (aAAaqwq/AGI-Super-Team, 105 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Architecture Pattern Selector?

alirezarezvani (a GitHub user) maintains it in alirezarezvani/claude-cto-team, which has 117 GitHub stars. The repository holds 12 skills in this directory. The repository was last updated on December 18, 2025.

Source: alirezarezvani/claude-cto-team on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.