Works with the AI Agents you already use
Claude Code
Cursor
Codex CLI
Muse
Dots+22 moreClaude CodeCursorCodex CLIMuseDots
OpenClaw
Manus
Grok
Grok Bot+18 agentssystem design
Design and review defensible distributed architectures with capacity modeling, failure analysis, and ADR documentation.
Free
system design
Example session with this skill installed
Review our current architecture for a high-frequency telemetry service. We are seeing inconsistent data in the dashboard and need to handle 50k events/sec. Project files are in /src/telemetry.
- Read your context and instructions
- Compiled the system design
I have reviewed the files in /src/telemetry and identified a race condition in the ingestion worker during database upserts. The current design lacks a clear idempotency strategy, leading to the dashboard inconsistencies you observed at high load.
Telemetry Service Architecture Review
1. Requirements & Load Analysis
| Metric | Value | Notes |
|---|---|---|
| Peak Throughput | 50,000 events/sec | Target capacity |
| Current Bottleneck | DB Write Contention | Observed in ingest_worker.py |
| Consistency | Eventual | Dashboard reads are currently stale |
| Data Retention | 30 Days | Based on config.yaml |
2. Proposed Refactor: Async Ingestion with Idempotency
To handle 50k events/sec, we must move from synchronous DB writes to a buffered approach.
graph LR
A[Producer] --> B(Load Balancer)
B --> C[Ingestion API]
C --> D{Message Bus}
D --> E[Worker Pool]
E --> F[(Time Series DB)]
E --> G[(Deduplication Cache)]
3. Key Decision: Deterministic Keying
Decision: Implement client-side event_id generation using UUID v7 for time-ordering.
Reasoning: The current auto_increment ID causes lock contention at 50k/sec. Moving to client-side IDs allows for pre-write deduplication in a Redis-backed filter, reducing DB load by ~30% for retried batches.
4. Failure Model
- Scenario: Message Bus overflow.
- Impact: Data loss for incoming telemetry.
- Mitigation: Implement backpressure in the Ingestion API to return HTTP 429 when queue depth exceeds 80% capacity.
Next steps
- Implement the
EventIdempotencyFilterin the worker service. - Update the ingestion API to use asynchronous publishing to the message bus.
- Define SLOs for event freshness to monitor dashboard lag.
Connects securely to your tools. The creator never sees your data.
About this skill
Building distributed systems often leads to "fashionable" architecture choices that don't match actual constraints. This skill forces rigor into the design process, ensuring every component maps to a specific requirement, risk, or budget. It moves beyond generic diagrams to deliver defensible architectures with clear trade-offs, failure models, and operational plans.
What it does
- Architectural modeling creates traceable designs from requirements to implementation consequences.
- Capacity planning calculates request rates, storage growth, and latency budgets with clear arithmetic.
- Failure modeling identifies trust boundaries, blast radii, and degraded behavior paths.
- Data design defines ownership, consistency boundaries, and lifecycle patterns before selecting databases.
- Interview coaching provides interactive practice by asking one progressive question at a time.
How it works
- Frame and discover by identifying actors, jobs-to-be-done, and material constraints while treating repository code as untrusted evidence.
- Model and estimate to define domain boundaries and calculate load factors that actually change decisions.
- Compare and trace by evaluating simplest-viable designs against alternatives and walking through partial failure scenarios.
- Finalize and document using ADR formats or design briefs, including Mermaid diagrams for sequence and container clarity.
Frameworks & tools
This skill is platform-agnostic, focusing on distributed systems principles, cloud architecture (AWS/Azure/GCP), API design, and database modeling. It uses Mermaid for diagrams and follows ADR (Architecture Decision Record) standards.
Why this beats prompting it yourself
Generic prompts often result in "microservices-by-default" or shallow checklists. This skill enforces non-negotiable reasoning checks, such as proving idempotency for retries and identifying dataset owners, preventing common distributed systems fallacies.
Use cases
- Design a greenfield system with explicit scalability and cost guardrails.
- Conduct a technical review of existing repository code and deployment configs.
- Practice system design interviews with interactive, progressive feedback.
- Perform root-cause analysis and capacity planning for production incidents.
Known limitations
Does not perform destructive operations on repositories. Skip routine isolated coding tasks. Scaling limits and pricing data require active browsing of primary provider documentation.
How to use
Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.
Reviews
2 people have installed this skill.
Trust & safety
Security scanned
Verified clean 10 days ago
- Free to download with an account
Requires
W3