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

System Design Methodology

by HoangNguyen0403 in HoangNguyen0403/agent-skills-standard

Drives an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs, computes capacity, then reveals components one by one, each justified by a constraint.

MITAuto-check passedDevOps & Cloud

Install System Design Methodology

skills CLI
$ npx skills add HoangNguyen0403/agent-skills-standard --skill system-design-methodology -a claude-code

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

GitHub CLI
$ gh skill install HoangNguyen0403/agent-skills-standard system-design-methodology --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/HoangNguyen0403/agent-skills-standard.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/system-design/system-design-methodology .claude/skills/system-design-methodology && 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
system-design-methodology
GitHub stars
572
Token cost
~1.8k tokens
SKILL.md length
836 words
Files
5 (incl. references)
Skills in repo
211
Repo updated
First seen
Licence
MIT

At a glance

Drives an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs, computes capacity, then reveals components one by one, each justified by a constraint.

  • Works in 5 steps: Classify Depth (always first) → Intake (gate) → Estimation (gate) → …
  • Designing a system
  • SKILL.md covers Priority: P0 (CRITICAL), Phase 0 - Classify Depth…, Phase 1 - Intake (gate) and Phase 2 - Estimation (gate), plus 9 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

System Design Methodology is an agent skill from HoangNguyen0403/agent-skills-standard. Drives an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs, computes capacity, then reveals components one by one, each justified by a constraint. Use when designing a system or running a design session; diagrams go through common-architecture-diagramming.

Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files (for example `evals/evals.json`, `references/four-phase-process.md` and `references/intake-checklist.md`).

It sits in DevOps & Cloud, covering Software architecture, Site reliability engineering and Diagrams. The repository describes itself as: A collection of Agent Skills Standard and Best Practice for Programming Languages, Frameworks that help our AI Agent follow best practies on frameworks and programming laguages. The licence is MIT.

When your agent uses it

  • Designing a system
  • Running a design session
  • Diagrams go through common-architecture-diagramming

Example prompts

  • “Use the system-design-methodology skill to drive an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs…”
  • “/system-design-methodology”

Workflow steps

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

  1. Classify Depth (always first)
  2. Intake (gate)
  3. Estimation (gate)
  4. High-Level Design (incremental)
  5. Deep Dives and Trade-offs

What it can do on your machine

Read from SKILL.md and the folder at commit b529c2d. 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.

    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

System Design Methodology loads about 1.8k tokens when it runs, and up to ~4.6k if it reads all its reference files. Until then it costs about 81 tokens; SKILL.md has 836 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~81
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.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 HoangNguyen0403/agent-skills-standard at commit b529c2d, republished under its MIT licence (© HoangNguyen0403). 836 words, ~1,788 tokens.

Download SKILL.mdSave it as .claude/skills/system-design-methodology/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
system-design-methodology
description
Drives an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs, computes capacity, then reveals components one by one, each justified by a constraint. Use when designing a system or running a design session; diagrams go through `common-architecture-diagramming`.

System Design Methodology

Priority: P0 (CRITICAL)

Requirements before solutions. Never draw a full architecture before numbers justify it.

Phase 0 - Classify Depth (always first)

  • Quick sketch: exploratory ask, no scale numbers available, answer needed now. Assume defaults, label each one ASSUMED, skip gates.
  • Full session: real build, migration, or budget commitment. Run every phase gate.
  • State depth and mode (new design | review existing | interview practice) in one line, then continue. Interview practice runs through system-design-interview-coaching: the round on a clock, the rubric after.
  • Escalate quick to full when a hard constraint or irreversible choice appears.

Phase 1 - Intake (gate)

  • Parse request: verbs to use cases, nouns to entities, adjectives to constraints.
  • Ask max 3 blocking questions per turn, each with a recommended default. See intake checklist.
  • Required before design: DAU/actors, top 3 use cases, read:write ratio, latency SLO, consistency need, retention, peak shape, budget, team size.
  • Freeze scope: list what is explicitly out of scope.

Phase 2 - Estimation (gate)

  • Compute QPS, storage, bandwidth, and working-set memory via system-design-estimation.
  • Present the numbers, name the one quantity that shapes the design, confirm before drawing anything.

Phase 3 - High-Level Design (incremental)

  • Price the null option first: do nothing, buy it, or let an existing service absorb it. Rejecting it needs a stated reason, not silence.
  • Start with the smallest system satisfying functional requirements: client, API, service, store.
  • Add one component at a time. For each, state constraint -> component -> cost in one line. No component without a named constraint.
  • Define API surface (one endpoint per functional requirement) and data ownership before optimizing.
  • Select views only when they answer a named question, per common-architecture-diagramming: a context/container, sequence, dataflow, deployment, or state view may be used when useful; prose or a table is sufficient otherwise. Carry metric and constraint only when the design states them; never invent a number to populate a node. See phase deliverables.

HLD, LLD, and Low-Level Design Routing

  • HLD answers audience-level boundaries, shaping constraints, ownership, failure domains, and the decision to make. Use context/container or prose only when that is enough; no diagram is mandatory.
  • LLD (the same lane as “low-level design”) answers one component or critical flow: data/state ownership, API or event contracts, ordering, idempotency, failure behavior, and verification. Use sequence, dataflow, or state only when that view resolves a named question.
  • Trace every handoff as requirement -> HLD decision -> component -> LLD contract -> verification. Give each link a stable ID and carry unresolved assumptions forward; an LLD must not silently change the HLD invariant.
  • Each selected view declares audience, question, decision, scenario, invariant, scope, status, evidence, and omissions. Lifecycle is proposed|implemented|retired; evidence is a citation, not confidence. Keep evidence_kind and evidence_confidence separate per the renderer-owned diagram spec and view manifest; never infer deployment from a code/document citation.
  • Views are evidence for a question, not a completeness checklist. Prefer a precise paragraph or table over a diagram that adds no decision value.
Show full SKILL.md (357 more words)Show less

Specialist Deep-Dive Contract

Select zero, one or multiple dives only for unresolved consequential risks; no quota or invented risks. Each brief names its decision, specialist profile, audience/question, workload/SLO/team/budget, invariant, scope, evidence status and HLD decision. Omit dives without decision impact.

  • Require options with rejection reasons, the recommended LLD contract, failure timeline/recovery, verification hooks, and any ADR reversal trigger. Merge the result back into the HLD-to-LLD trace before scoring.

Brownfield Path (review-existing mode)

  • Map current state before proposing anything: components, owners, traffic, incidents.
  • Measure, do not assume: pull real QPS, data volume, and p99 from the running system.
  • Find the binding constraint - the one that fails first at the next growth step.
  • Design the smallest change that moves it, then re-measure. A rewrite needs a structural constraint the current shape cannot satisfy.

Phase 4 - Deep Dives and Trade-offs

  • Stage what to build now, the enabling seam and metric threshold; record one ADR per irreversible decision with its reversal trigger, then score with system-design-review.

Design-to-Delivery Gate

  • Once HLD/LLD is fixed, list bounded docs/diagram slices: exact files, evidence, acceptance, verification, integrator. Route production to the cheapest qualified configured executor if available; lead owns decisions and final review.
  • If still defective after one focused correction, use the configured fallback or report BLOCKED. Log executor/model, corrections, exceptions and fallback reason; report actual usage/cost or unavailable, never assumed savings.

Anti-Patterns

  • No architecture before requirements: no diagram until Phase 1 answers exist or defaults are flagged.
  • No unjustified components: every box names the constraint it solves.
  • No design without the null option: state why doing nothing or buying loses before building.
  • No silent assumptions: an unknown input becomes a labeled ASSUMED default, never a hidden guess.
  • No full-stack reveal: never dump a finished diagram before incremental agreement.

Red Flags

  • Stop if "just give me the architecture": deliver a quick sketch with ASSUMED labels, not fake precision.
  • Stop if scale is unknown at Phase 3: return to Phase 2 and estimate from a stated assumption.

References

© HoangNguyen0403, 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 4 other files (references) in skills/system-design/system-design-methodology of HoangNguyen0403/agent-skills-standard.

  • SKILL.md
  • evals/evals.json
  • references/four-phase-process.md
  • references/intake-checklist.md
  • references/phase-deliverables.md

Open the folder on GitHubat commit b529c2d

Compare with similar skills

System Design Methodology 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.

System Design Methodology compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
System Design Methodology this skillHoangNguyen0403/agent-skills-standard572—~1.8kAutomated safety check: PassMIT
Azure Diagramscmb211087/azure-diagrams-skill150—~4kAutomated safety check: NotesMIT
Google Cloud Solution Architecturegoogle/skills21k—~3.5kAutomated safety check: PassApache-2.0
System Designninehills/skills280—~4.7kAutomated safety check: PassMIT
System Designwondelai/skills2.4k—~4kAutomated safety check: PassMIT
Archify Diagramstt-a1i/archify82k—~2.9kAutomated safety check: PassMIT

Similar skills

  • Azure Diagrams

    cmb211087/azure-diagrams-skill

    Comprehensive technical diagramming toolkit for solutions architects, presales, and developers.

    150 GitHub stars~4k tokensUpdated 3 mo ago
    DevOps & CloudAuto-check: notes

  • Google Cloud Solution Architecture

    google/skills

    Official

    Interactively discovers requirements and designs holistic, multi-product system architectures, solution blueprints, and deployment recommendations for complex workloads on Google Cloud.

    21k GitHub stars~3.5k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • System Design

    ninehills/skills

    Design scalable distributed systems using structured approaches for load balancing, caching, database scaling, and message queues.

    280 GitHub stars~4.7k tokensUpdated 3 mo ago
    Backend & APIsAuto-check passed

  • System Design

    wondelai/skills

    Design scalable distributed systems using structured approaches for load balancing, caching, database scaling, and message queues.

    2.4k GitHub stars~4k tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed

  • Archify Diagrams

    tt-a1i/archify

    Creates interactive architecture, workflow, sequence, data-flow and lifecycle diagrams as standalone HTML with inline SVG, themes and image or video export.

    82k GitHub stars~2.9k tokensUpdated today
    DevelopmentAuto-check passed

  • Dark Architecture Diagram Builder

    Cocoon-AI/architecture-diagram-generator

    Creates dark-themed system, cloud, security and network architecture diagrams as self-contained HTML files with inline SVG and CSS.

    7.4k GitHub starsUsed in 1 repo~2.1k tokens
    DevelopmentAuto-check passed

More from HoangNguyen0403/agent-skills-standard

All 211 skills in this repo

  • Subagent-Driven Development

    HoangNguyen0403/agent-skills-standard

    Runs a multi-task implementation plan by sending each task to a fresh implementer subagent, reviewing it independently, then reviewing the whole branch.

    572 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

  • draw.io Architecture Diagramming

    HoangNguyen0403/agent-skills-standard

    Draws architecture diagrams as editable draw.io files from a JSON spec, with a fixed house style, one C4 level per diagram and evidence-tagged shapes.

    572 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

  • Android Navigation 3 Guide

    HoangNguyen0403/agent-skills-standard

    Implements and migrates to Jetpack Navigation 3 in Compose: NavDisplay, typed route objects, a state-list back stack, deep links, multiple back stacks and dialog scenes.

    572 GitHub stars~687 tokensUpdated yesterday
    Auto-check passed

  • Angular HttpClient Standards

    HoangNguyen0403/agent-skills-standard

    Sets rules for Angular HTTP code: functional interceptors, typed requests, services that own every call, and httpResource for reactive data loading in Angular 17+.

    572 GitHub stars~652 tokensUpdated yesterday
    Auto-check passed

  • Angular Tooling

    HoangNguyen0403/agent-skills-standard

    Angular CLI usage, code generation, build configuration, and bundle optimization.

    572 GitHub stars~743 tokensUpdated yesterday
    Auto-check passed

  • Common Code Review

    HoangNguyen0403/agent-skills-standard

    Conduct high-quality, persona-driven code reviews. An agent skill from HoangNguyen0403/agent-skills-standard.

    572 GitHub stars~772 tokensUpdated yesterday
    Auto-check passed

Categories

Questions about System Design Methodology

What does System Design Methodology do?

Drives an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs, computes capacity, then reveals components one by one, each justified by a constraint. System Design Methodology is an agent skill from HoangNguyen0403/agent-skills-standard. Drives an interactive system design session: classifies depth, elicits scale/SLO/consistency inputs, computes capacity, then reveals components one by one, each justified by a constraint.

When should I use System Design Methodology?

System Design Methodology fits situations like: designing a system; running a design session; diagrams go through common-architecture-diagramming.

How do I install System Design Methodology in Claude Code?

Run `npx skills add HoangNguyen0403/agent-skills-standard --skill system-design-methodology -a claude-code`. Or copy the skill folder (skills/system-design/system-design-methodology in HoangNguyen0403/agent-skills-standard) into .claude/skills/system-design-methodology in your project. Claude Code loads it when a task matches its description.

How do I install System Design Methodology in Codex?

Run `npx skills add HoangNguyen0403/agent-skills-standard --skill system-design-methodology -a codex`. Or copy the skill folder (skills/system-design/system-design-methodology in HoangNguyen0403/agent-skills-standard) into .agents/skills/system-design-methodology in your project. Codex loads it when a task matches its description.

Can I use System Design Methodology 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 HoangNguyen0403/agent-skills-standard --skill system-design-methodology -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/system-design-methodology, .gemini/skills/system-design-methodology, .github/skills/system-design-methodology and .opencode/skills/system-design-methodology in your project.

What does System Design Methodology need to run?

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

Does System Design Methodology 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 System Design Methodology 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 System Design Methodology use?

System Design Methodology 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 System Design Methodology use?

About 1.8k tokens (SKILL.md is roughly 7.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.8k tokens, read only when the agent opens those files.

What are the alternatives to System Design Methodology?

Skills that share tags, products or a category with System Design Methodology: Azure Diagrams (cmb211087/azure-diagrams-skill, 150 stars), Google Cloud Solution Architecture (google/skills, 21k stars), System Design (ninehills/skills, 280 stars) and System Design (wondelai/skills, 2.4k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains System Design Methodology?

HoangNguyen0403 (a GitHub user) maintains it in HoangNguyen0403/agent-skills-standard, which has 572 GitHub stars. The repository holds 211 skills in this directory. The repository was last updated on October 9, 2026.

Source: HoangNguyen0403/agent-skills-standard on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.