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

Scalability Advisor

by alirezarezvani in alirezarezvani/claude-cto-team

Guidance for scaling systems from startup to enterprise scale.

MITAuto-check passedBackend & APIs

Install Scalability Advisor

skills CLI
$ npx skills add alirezarezvani/claude-cto-team --skill scalability-advisor -a claude-code

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

GitHub CLI
$ gh skill install alirezarezvani/claude-cto-team scalability-advisor --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/scalability-advisor .claude/skills/scalability-advisor && 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
scalability-advisor
GitHub stars
117
Token cost
~3.7k tokens
SKILL.md length
562 words
Files
1
Skills in repo
12
Repo updated
First seen
Licence
MIT

At a glance

Guidance for scaling systems from startup to enterprise scale.

  • Works in 4 steps: Startup (0-10K Users) → Growth (10K-100K Users) → Scale (100K-1M Users) → …
  • Planning for growth
  • SKILL.md covers When to Use, Scaling Stages Framework, Stage 1: Startup (0-10K Users) and Stage 2: Growth (10K-100K Users), plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Scalability Advisor is an agent skill from alirezarezvani/claude-cto-team. Guidance for scaling systems from startup to enterprise scale. Use when planning for growth, diagnosing bottlenecks, or designing systems that need to handle 10x-1000x current load.

Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Caching. 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

  • Planning for growth
  • Diagnosing bottlenecks
  • Designing systems that need to handle 10x-1000x current load

Example prompts

  • “/scalability-advisor”

Workflow steps

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

  1. Startup (0-10K Users)
  2. Growth (10K-100K Users)
  3. Scale (100K-1M Users)
  4. Enterprise (1M+ Users)

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 sql and 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

Scalability Advisor loads about 3.7k tokens when it runs. Until then it costs about 50 tokens; SKILL.md has 562 words of instructions outside code blocks.

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

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). 562 words, ~3,747 tokens.

Download SKILL.mdSave it as .claude/skills/scalability-advisor/SKILL.md (or your agent's skills folder).
name
scalability-advisor
description
Guidance for scaling systems from startup to enterprise scale. Use when planning for growth, diagnosing bottlenecks, or designing systems that need to handle 10x-1000x current load.

Scalability Advisor

Provides systematic guidance for scaling systems at different growth stages, identifying bottlenecks, and designing for horizontal scalability.

When to Use

  • Planning for 10x, 100x, or 1000x growth
  • Diagnosing current performance bottlenecks
  • Designing new systems for scale
  • Evaluating scaling strategies (vertical vs. horizontal)
  • Capacity planning and infrastructure sizing

Scaling Stages Framework

Stage Overview
┌─────────────────────────────────────────────────────────────────────┐
│                    SCALING JOURNEY                                  │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Stage 1        Stage 2         Stage 3         Stage 4             │
│  Startup        Growth          Scale           Enterprise          │
│  0-10K users    10K-100K        100K-1M         1M+ users           │
│                                                                     │
│  Single         Add caching,    Horizontal      Global,             │
│  server         read replicas   scaling         multi-region        │
│                                                                     │
│  $100/mo        $1K/mo          $10K/mo         $100K+/mo           │
└─────────────────────────────────────────────────────────────────────┘

Stage 1: Startup (0-10K Users)

Architecture
┌────────────────────────────────────────┐
│           Single Server                │
│  ┌──────────────────────────────────┐  │
│  │  App Server (Node/Python/etc)    │  │
│  │  + Database (PostgreSQL)         │  │
│  │  + File Storage (local/S3)       │  │
│  └──────────────────────────────────┘  │
└────────────────────────────────────────┘
Key Metrics
MetricTargetWarning
Response time (P95)< 500ms> 1s
Database queries/request< 10> 20
Server CPU< 70%> 85%
Database connections< 50% pool> 80% pool
What to Focus On

DO:

  • Write clean, maintainable code
  • Use database indexes on frequently queried columns
  • Implement basic monitoring (uptime, errors)
  • Keep architecture simple (monolith is fine)

DON'T:

  • Over-engineer for scale you don't have
  • Add caching before you need it
  • Split into microservices prematurely
  • Worry about multi-region yet
When to Move to Stage 2
  • Database CPU consistently > 70%
  • Response times degrading
  • Single queries taking > 100ms
  • Server resources maxed

Stage 2: Growth (10K-100K Users)

Architecture
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│    ┌─────────┐      ┌─────────────────────────────────┐     │
│    │   CDN   │      │      Load Balancer              │     │
│    └────┬────┘      └──────────────┬──────────────────┘     │
│         │                          │                        │
│         │           ┌──────────────┼──────────────┐         │
│         │           │              │              │         │
│         ▼           ▼              ▼              ▼         │
│    ┌─────────┐ ┌─────────┐   ┌─────────┐   ┌─────────┐      │
│    │ Static  │ │ App 1   │   │ App 2   │   │ App 3   │      │
│    │ Assets  │ └────┬────┘   └────┬────┘   └────┬────┘      │
│    └─────────┘      │             │             │           │
│                     └──────────────┼────────────┘           │
│                                    │                        │
│                     ┌──────────────┼──────────────┐         │
│                     │              │              │         │
│                     ▼              ▼              ▼         │
│               ┌─────────┐   ┌─────────┐   ┌─────────┐       │
│               │ Primary │   │  Read   │   │  Redis  │       │
│               │   DB    │───│ Replica │   │  Cache  │       │
│               └─────────┘   └─────────┘   └─────────┘       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
Key Additions
ComponentPurposeWhen to Add
CDNStatic asset cachingImages, JS, CSS taking > 20% bandwidth
Load BalancerDistribute trafficSingle server CPU > 70%
Read ReplicasOffload reads> 80% database ops are reads
Redis CacheApplication cachingSame queries repeated frequently
Job QueueAsync processingBackground tasks blocking requests
Caching Strategy
Request Flow with Caching:

1. Check CDN (static assets)         ─► HIT: Return cached
                                           │
2. Check Application Cache (Redis)   ─► HIT: Return cached
                                           │
3. Check Database                    ─► Return + Cache result

What to Cache:

  • Session data (TTL: session duration)
  • User profile data (TTL: 5-15 minutes)
  • API responses (TTL: varies by freshness needs)
  • Database query results (TTL: 1-5 minutes)
  • Computed values (TTL: based on computation cost)
Database Optimization
sql
-- Find slow queries
SELECT query, calls, mean_time, total_time
FROM pg_stat_statements
ORDER BY total_time DESC
LIMIT 20;

-- Find missing indexes
SELECT schemaname, tablename, indexrelname, idx_scan, seq_scan
FROM pg_stat_user_indexes
WHERE idx_scan = 0 AND seq_scan > 1000;
When to Move to Stage 3
  • Write traffic overwhelming single primary
  • Cache hit rate plateauing despite optimization
  • Read replicas can't keep up with replication lag
  • Need independent scaling of components

Stage 3: Scale (100K-1M Users)

Architecture
┌──────────────────────────────────────────────────────────────────────┐
│                           CDN / Edge                                 │
└──────────────────────────────────────────────────────────────────────┘
                                    │
┌──────────────────────────────────────────────────────────────────────┐
│                        API Gateway                                   │
│              (Rate limiting, Auth, Routing)                          │
└──────────────────────────────────────────────────────────────────────┘
                                    │
        ┌───────────────────────────┼───────────────────────────┐
        │                           │                           │
        ▼                           ▼                           ▼
┌───────────────┐          ┌───────────────┐          ┌───────────────┐
│   Service A   │          │   Service B   │          │   Service C   │
│   (Users)     │          │   (Orders)    │          │   (Search)    │
│   Auto-scale  │          │   Auto-scale  │          │   Auto-scale  │
└───────┬───────┘          └───────┬───────┘          └───────┬───────┘
        │                          │                          │
        ▼                          ▼                          ▼
┌───────────────┐          ┌───────────────┐          ┌───────────────┐
│   User DB     │          │   Order DB    │          │ Elasticsearch │
│   (Sharded)   │          │   (Sharded)   │          │   (Cluster)   │
└───────────────┘          └───────────────┘          └───────────────┘
                                    │
                                    ▼
                    ┌───────────────────────────┐
                    │     Message Queue         │
                    │     (Kafka / SQS)         │
                    └───────────────────────────┘
Key Patterns
Database Sharding
Sharding Strategies:

1. Hash-based (user_id % num_shards)
   PRO: Even distribution
   CON: Hard to add shards

2. Range-based (user_id 1-1M → shard 1)
   PRO: Easy to add shards
   CON: Hotspots possible

3. Directory-based (lookup table)
   PRO: Flexible
   CON: Lookup overhead
Event-Driven Architecture
Synchronous → Asynchronous

Before:
  API → Service A → Service B → Service C → Response (slow)

After:
  API → Service A → Queue → Response (fast)
                      ↓
              Service B, C process async
Scaling Checklist
  • Stateless application servers (no local state)
  • Database read/write separation
  • Asynchronous processing for non-critical paths
  • Circuit breakers between services
  • Distributed tracing implemented
  • Auto-scaling configured with proper metrics
  • Database connection pooling (PgBouncer, ProxySQL)
When to Move to Stage 4
  • Need geographic distribution for latency
  • Regulatory requirements (data residency)
  • Single region can't handle failover
  • Global user base with latency requirements
Show full SKILL.md (215 more words)Show less

Stage 4: Enterprise (1M+ Users)

Architecture
┌─────────────────────────────────────────────────────────────────────────┐
│                          Global Load Balancer                           │
│                       (GeoDNS, Anycast, Route53)                        │
└─────────────────────────────────────────────────────────────────────────┘
                    │                                │
           ┌────────┴────────┐              ┌───────┴────────┐
           │                 │              │                │
           ▼                 ▼              ▼                ▼
    ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
    │  US-East     │  │  US-West     │  │  EU-West     │  │  AP-South    │
    │  Region      │  │  Region      │  │  Region      │  │  Region      │
    │  ┌────────┐  │  │  ┌────────┐  │  │  ┌────────┐  │  │  ┌────────┐  │
    │  │Services│  │  │  │Services│  │  │  │Services│  │  │  │Services│  │
    │  └────────┘  │  │  └────────┘  │  │  └────────┘  │  │  └────────┘  │
    │  ┌────────┐  │  │  ┌────────┐  │  │  ┌────────┐  │  │  ┌────────┐  │
    │  │Database│  │  │  │Database│  │  │  │Database│  │  │  │Database│  │
    │  │(Primary)│ │  │  │(Replica)│ │  │  │(Primary)│ │  │  │(Replica)│ │
    │  └────────┘  │  │  └────────┘  │  │  └────────┘  │  │  └────────┘  │
    └──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘
                              │                   │
                              └─────────┬─────────┘
                                        │
                              Cross-Region Replication
Multi-Region Patterns
PatternConsistencyLatencyComplexity
Active-PassiveStrongHigh failoverLow
Active-ActiveEventualLowHigh
Follow-the-SunStrong per regionMediumMedium
Data Consistency Strategies
CAP Theorem Trade-offs:

Strong Consistency (CP):
- All regions see same data
- Higher latency for writes
- Use for: Financial transactions, inventory

Eventual Consistency (AP):
- Regions may have stale data briefly
- Low latency always
- Use for: Social feeds, analytics, non-critical

Causal Consistency:
- Related operations ordered correctly
- Balance of latency and correctness
- Use for: Messaging, collaboration
Enterprise Checklist
  • Multi-region deployment
  • Cross-region data replication
  • Global CDN with edge caching
  • Disaster recovery tested
  • Compliance (SOC 2, GDPR, data residency)
  • 99.99% SLA architecture
  • Zero-downtime deployments
  • Chaos engineering practice

Bottleneck Diagnosis Guide

Finding the Bottleneck
Systematic Diagnosis:

1. Where is time spent?
   └─► Distributed tracing (Jaeger, Datadog)

2. Is it the database?
   └─► Check slow query logs, connection pool

3. Is it the application?
   └─► CPU profiling, memory analysis

4. Is it the network?
   └─► Latency between services, DNS resolution

5. Is it external services?
   └─► Third-party API latency, rate limits
Common Bottlenecks by Layer
LayerSymptomsSolutions
DatabaseSlow queries, high CPUIndexing, read replicas, caching
ApplicationHigh CPU, memoryOptimize code, scale horizontally
NetworkHigh latency, timeoutsCDN, edge caching, connection pooling
StorageSlow I/O, high waitSSD, object storage, caching
External APIsTimeouts, rate limitsCircuit breakers, caching, fallbacks
Database Bottleneck Checklist
markdown
## Quick Database Health Check

1. Connection Pool
   - Current connections vs max?
   - Connection wait time?
   - Pool exhaustion events?

2. Query Performance
   - Slowest queries (pg_stat_statements)?
   - Missing indexes (seq scans > 10K)?
   - Lock contention?

3. Replication
   - Replica lag?
   - Write throughput?
   - Read distribution?

4. Storage
   - Disk I/O wait?
   - Table/index bloat?
   - WAL write latency?

Scaling Calculations

Capacity Planning Formula
Required Capacity = Peak Traffic × Growth Factor × Safety Margin

Example:
- Current peak: 1,000 req/sec
- Expected growth: 3x in 12 months
- Safety margin: 1.5x

Required: 1,000 × 3 × 1.5 = 4,500 req/sec capacity
Database Sizing
Connection Pool Size:
  connections = (num_cores × 2) + effective_spindle_count

  Example: 8 cores, SSD
  connections = (8 × 2) + 1 = 17 connections per instance

Read Replica Sizing:
  replicas = ceiling(read_traffic / single_replica_capacity)

  Example: 10,000 reads/sec, 3,000/replica capacity
  replicas = ceiling(10,000 / 3,000) = 4 replicas
Cache Sizing
Cache Size:
  memory = working_set_size × (1 + overhead_factor)

  Working set = frequently accessed data (usually 10-20% of total)
  Overhead = ~1.5x for Redis data structures

  Example: 10GB working set
  Redis memory = 10GB × 1.5 = 15GB

Quick Reference

Scaling Decision Matrix
SymptomFirst TryThen TryFinally
Slow page loadsAdd cachingCDNEdge compute
Database slowAdd indexesRead replicasSharding
API timeoutsAsync processingCircuit breakersEvent-driven
High server CPUVertical scaleHorizontal scaleOptimize code
High memoryIncrease RAMFix memory leaksRedesign data structures
Infrastructure Cost at Scale
UsersArchitectureMonthly Cost
10KSingle server$100-300
100KLoad balanced + cache$1,000-3,000
1MMicroservices + sharding$10,000-30,000
10MMulti-region$100,000+

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

Just SKILL.md in skills/scalability-advisor of alirezarezvani/claude-cto-team.

Open the folder on GitHubat commit a5bbb78

Compare with similar skills

Scalability Advisor 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.

Scalability Advisor compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Scalability Advisor this skillalirezarezvani/claude-cto-team117—~3.7kAutomated safety check: PassMIT
Stripe Projectsfossasia/eventyay1.7k5 repos~2kAutomated safety check: NotesApache-2.0
FoundatioFoundatioFx/Foundatio2.1k—~3.9kAutomated safety check: PassApache-2.0
Wp Block Themesgambitph/Stackable3503 repos~985Automated safety check: PassGPL-3.0
Wp Performancegambitph/Stackable3503 repos~1.5kAutomated safety check: PassGPL-3.0
Effect Portable Patternsmillionco/expect3.6k—~3.7kAutomated safety check: PassCustom licence

Similar skills

  • Stripe Projects

    fossasia/eventyay

    A skill your agent uses when the user wants to provision infrastructure or third-party services using Stripe Projects.

    1.7k GitHub starsUsed in 5 repos~2k tokens
    Backend & APIsAuto-check: notes

  • Foundatio

    FoundatioFx/Foundatio

    A skill your agent uses when working with Foundatio infrastructure abstractions for .NET -- caching, queuing, messaging, file storage, distributed locking, or background jobs.

    2.1k GitHub stars~3.9k tokensUpdated today
    Backend & APIsAuto-check passed

  • Wp Block Themes

    gambitph/Stackable

    A skill your agent uses when developing WordPress block themes: theme.json (global settings/styles), templates and template parts, patterns, style variations, and Site Editor troubleshooting (style…

    350 GitHub starsUsed in 3 repos~985 tokens
    Backend & APIsAuto-check passed

  • Wp Performance

    gambitph/Stackable

    A skill your agent uses when investigating or improving WordPress performance (backend-only agent): profiling and measurement (WP-CLI profile/doctor, Server-Timing, Query Monitor via REST headers)…

    350 GitHub starsUsed in 3 repos~1.5k tokens
    Backend & APIsAuto-check passed

  • Effect Portable Patterns

    millionco/expect

    Portable Effect patterns for robust promise execution. An agent skill from millionco/expect.

    3.6k GitHub stars~3.7k tokensUpdated 5 mo ago
    Backend & APIsAuto-check passed

  • FastAPI-Redis SDK Development

    redis/fastapi-redis-sdk

    Official

    Guides development on the fastapi-redis-sdk library itself - its connection lifecycle, dependency-injected caching, and async/sync bridging.

    404 GitHub stars~2.5k tokensUpdated 7 days ago
    Backend & APIsAuto-check: notes

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

  • Architecture Pattern Selector

    alirezarezvani/claude-cto-team

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

    117 GitHub stars~1.6k 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

Categories

Questions about Scalability Advisor

What does Scalability Advisor do?

Guidance for scaling systems from startup to enterprise scale. Scalability Advisor is an agent skill from alirezarezvani/claude-cto-team. Guidance for scaling systems from startup to enterprise scale.

When should I use Scalability Advisor?

Scalability Advisor fits situations like: planning for growth; diagnosing bottlenecks; designing systems that need to handle 10x-1000x current load.

How do I install Scalability Advisor in Claude Code?

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

How do I install Scalability Advisor in Codex?

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

Can I use Scalability Advisor 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 scalability-advisor -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/scalability-advisor, .gemini/skills/scalability-advisor, .github/skills/scalability-advisor and .opencode/skills/scalability-advisor in your project.

What does Scalability Advisor need to run?

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

Does Scalability Advisor 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 Scalability Advisor 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 Scalability Advisor use?

Scalability Advisor 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 Scalability Advisor use?

About 3.7k tokens (SKILL.md is roughly 15k 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 Scalability Advisor?

Skills that share tags, products or a category with Scalability Advisor: Stripe Projects (fossasia/eventyay, 1.7k stars), Foundatio (FoundatioFx/Foundatio, 2.1k stars), Wp Block Themes (gambitph/Stackable, 350 stars) and Wp Performance (gambitph/Stackable, 350 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Scalability Advisor?

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.