hermes

Review a system design

Reviews a design document or proposal for failure modes, scaling limits, data and consistency risks and operability gaps, and returns ranked findings. Use before a design review or before building.

context

You are reviewing a design before the team builds it. The goal is to find what will fail in production or block the team later, while it is still cheap to change. Generic advice ("consider caching", "think about security") wastes the author's time; every finding must point to a part of this design and a concrete way it goes wrong.

task

Review this design: Only if [REQUIREMENTS] is given: Requirements it must meet: Weight your attention toward: .

  1. Restate the design in at most 5 lines: the components, the main request or data flow, and the requirements it targets. List any non-functional requirement that is missing and would change the design (load, latency, availability, durability, data size, cost).
  2. Walk each critical path step by step. For every component and dependency on it, ask: what happens when it is slow, down, returns an error, returns duplicates, or delivers out of order? What retries, and is the retried operation idempotent?
  3. Check the data: the source of truth for each entity, who writes it, consistency between stores, schema migrations, retention and personal data.
  4. Check scale with back-of-the-envelope maths, using only the numbers given. Show the arithmetic. Find the first component to saturate.
  5. Check operability: deploy and rollback, backward compatibility during rollout, observability (what alert would fire, which dashboard shows it) and the on-call burden.
  6. Note security boundaries only at design level: trust boundaries, authentication between components, secrets.
  7. Keep only findings you can tie to a specific part of the design and a concrete scenario. Rank them by impact times likelihood.
constraints
  • At most 12 findings. Each one quotes or names the section of the design it is about.
  • Do not redesign the system. Recommend the smallest change that removes the risk, and say when a bigger rethink is needed.
  • Do not push complexity the requirements do not justify (extra services, queues, caches, sharding). Say so when the simple design is right.
  • Do not invent numbers, product limits or prices. Label any figure you did not get from the input as an assumption.
  • Separate what you verified from what you inferred. Mark inferences as such.
  • When you do not know, say "I don't know" once and state what would settle it.
output format

Verdict

One line: ready | ready with changes | needs another pass, plus the single most important reason.

Design in brief

At most 5 lines, then missing requirements as bullets.

Findings

Numbered, most severe first. Each: [blocker | major | minor] title — where in the design — the scenario that triggers it — the impact — the recommended change.

Questions for the author

Questions whose answers would change a finding or the verdict.

What works

Up to 3 bullets on choices worth keeping, so they survive the revision.

1 required value still a placeholder; the assistant will ask for it.

details

kind
Prompt: a task you run by name to get one finished thing back
domain
Software engineering
category
Architecture
level
Expert
made for
Software architect, Tech lead / staff engineer, Software engineer, Engineering manager
risk
read-only
version
v1.0.0 · experimental
reviewed
2026-10-02
works in
Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Antigravity, OpenCode, Windsurf, Zed, Continue, AGENTS.md, ChatGPT, claude.ai

Edit on GitHubReport a problem

use in

Hodios CLI
npx @hermes-hq/hodios install review-system-design --target claude-code
Agent Skills
npx skills add hermes-hq/hodios-dist --skill review-system-design -a claude-code
Add the Hodios marketplace (once)
claude plugin marketplace add hermes-hq/hodios-dist
Install the software-engineering plugin
claude plugin install hodios-software-engineering@hodios

The plugin brings every entry in this domain at once.

pairs well with

All of Architecture
PersonaArchitecture

Software architect

Acts as a pragmatic software architect who designs from requirements and constraints, names trade-offs and failure modes, and keeps designs as simple as the problem allows.

software-architect
PromptArchitecture

Write an architecture decision record

Writes an architecture decision record that states one decision, the forces behind it, the options weighed and the honest consequences. Use when a significant technical choice is made or proposed.

write-adr
PromptArchitecture

Compare design options

Compares two to four technical options against the criteria that matter, weighs reversibility and risk, and recommends one. Use when a team is stuck choosing between approaches or tools.

compare-design-options
PromptArchitecture

Design an API contract

Designs an API contract before implementation, with operations, schemas, errors, pagination, idempotency and evolution rules. Use when adding an API that other teams or clients will call.

design-api-contract
PromptArchitecture

Write an engineering design doc

Writes an engineering design doc or RFC with context, goals and non-goals, options and trade-offs, the decision, risks and a rollout plan. Use before building a change that needs review or buy-in.

write-design-doc
WorkflowArchitecture

API design track

Takes a new API from consumer needs to a resource model, a reviewed contract, error and versioning rules, and a mock with contract tests, pausing for approval between steps.

api-design-track