Structure system design discussions across architecture, tradeoffs, risks, and migration planning.
This skill appears to be a prompt-only/methodology-style Skill with no required secrets, no declared remote endpoints, and no stated local code execution or file/data access capabilities. The main concern is limited supply-chain assurance: it is open-source on GitHub and appears Microsoft-associated, but the license is unspecified, stars are minimal, and maintenance status is unknown, so basic source verification is advisable before production use.
The materials explicitly state that no keys or environment variables are required; there is no indication of token collection, storage, forwarding, or credential abuse.
No remote endpoints are declared, and the skill is marked prompt-only; the documentation focuses on conversation flow and delegation methodology, with no evidence that it independently sends user data to external services.
As a Skill document, it contains methodology and delegation examples rather than instructions to spawn local processes, run scripts, or invoke system capabilities. The delegate/recipes calls in the README are illustrative workflow examples, not evidence of execution privileges granted by this material itself.
There is no stated ability to read or write local files, databases, clipboard contents, or other resources; the description is focused on guiding system design conversations and phase validation, suggesting a minimal data access surface.
Positive factors include a public GitHub repository and auditable open-source code, with what appears to be an official-source signal; however, the license is unspecified, community adoption is extremely low (0 stars), and maintenance status is unknown, so supply-chain trust still warrants manual verification. No concrete red flags justify a high-risk rating.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "systems-design-methodology" skill from askskill: 1. Download https://raw.githubusercontent.com/microsoft/amplifier-bundle-systems-design/main/skills/systems-design-methodology/SKILL.md 2. Save it as ~/.claude/skills/systems-design-methodology/SKILL.md 3. Reload skills and tell me it's ready
Use the nine-phase system design methodology to design an e-commerce order system for flash sales. Cover problem framing, system classification, constraints, candidate architectures, tradeoff analysis, key risks, refinements, migration plan, and final documentation summary.
A structured system design proposal with architecture rationale, capacity and risk analysis, and implementation migration steps.
I am planning a centralized logging platform. Review the design with the nine-phase methodology and list key validation checkpoints for me at each phase, especially around cost, scalability, and operational complexity.
An architecture review with user validation checkpoints, clear decisions, tradeoff reasoning, and recommended next improvements.
For an existing monolithic SaaS system, use the nine-phase system design methodology to create a migration roadmap to microservices, including decomposition principles, risk controls, transition architecture, and documentation deliverables.
A phased migration roadmap covering service decomposition strategy, transition approach, risk mitigation, and documentation outputs.
Companion skill for the /systems-design mode. The mode gates tools; this skill governs behavior.
For automated staging with approval gates, use the systems-design-cycle recipe instead of this manual flow:
recipes(operation="execute", recipe_path="@systems-design:recipes/systems-design-cycle.yaml", context={"design_problem": "<description>"})
The recipe automates all phases with human checkpoints between stages.
You handle the CONVERSATION. Agents handle the ANALYSIS.
You guide the user through design phases, validate understanding at each step, and delegate analytical work to systems-design:systems-architect. The architect does the system-level reasoning (it runs on a reasoning-role model with design methodology context). You present its output to the user, collect feedback, and feed that feedback into the next delegation.
Progress through these phases in order. Each phase ends with explicit user validation before moving on. You may revisit earlier phases if the user's feedback reveals gaps.
Gather the user's initial description, then delegate to the architect to build the system map:
delegate(
agent="systems-design:systems-architect",
instruction="ANALYZE mode. Build a system map for: [user's description].
Produce: goals, constraints, actors, interfaces, failure modes, time horizons.
Do NOT propose solutions -- map the problem only.",
context_depth="recent"
)
Present the architect's system map to the user. Ask: "Does this capture the problem correctly? What am I missing?"
Do NOT proceed until the user validates the problem framing. If they correct the map, re-delegate with the corrections.
If this modifies an existing system, apply the Comprehending Existing lens before generating the map:
Include this context in the architect delegation so candidates respect existing design intent.
This phase is mandatory. Do not skip it. Do not proceed to candidate architectures without completing it.
Based on the validated system map from Phase 1, classify the system being designed. Produce a brief taxonomy:
System types -- which of these apply? List ALL that match, not just the primary one:
| Type | Skill | Applies when... |
|---|---|---|
| Web service / API | system-type-web-service | HTTP endpoints, REST/GraphQL, request-response |
| Event-driven | system-type-event-driven | Message queues, event logs, pub/sub, hooks, reactive patterns |
| Data pipeline | system-type-data-pipeline | Batch/streaming processing, ETL, DAG scheduling |
| Workflow orchestration | system-type-workflow-orchestration | Multi-step processes, sagas, durable execution |
| CLI tool | system-type-cli-tool | Command-line interface, subcommands, plugin architecture |
| Real-time | system-type-real-time | WebSockets, persistent connections, state sync |
| Multi-tenant SaaS | system-type-multi-tenant-saas | Tenant isolation, shared infrastructure, billing |
| ML serving | system-type-ml-serving | Model serving, feature stores, inference pipelines |
| Distributed system | system-type-distributed | Consensus, replication, partitioning, multi-node coordination |
| Enterprise integration | system-type-enterprise-integration | Legacy modernization, API gateways, data integration |
| Edge / offline-first | system-type-edge-offline | Offline operation, sync protocols, constrained resources |
| Single-page app | system-type-spa | Client-side routing, state management, rendering strategies |
…
Design and evaluate core mechanisms, tradeoffs, and failures in distributed systems.
Design offline-first edge systems with sync, conflict handling, and weak-network resilience.
Design and assess enterprise integration patterns, legacy modernization, and orchestration strategies.
Review system designs with a seven-step method to surface risks and improvements.
Evaluate system designs through Unix/Linux principles for simplicity and composability.
Model complex domains and define system boundaries with Domain-Driven Design.
Design systems and architectures with APIs, data models, and service boundaries.
Design and evaluate event-driven, message-based, and asynchronous system architectures.
Design and evaluate CLI tools and developer SDK architecture and usability.
Create or review ADRs to compare technologies and document design trade-offs.
Document agent decisions and pass structured context during agent handoffs.
Systematically investigate bugs before fixing them with a four-phase debugging framework.