Help us improve
Share bugs, ideas, or general feedback.
From flow
Design or review architecture for a feature or system. Analyzes existing patterns, evaluates coupling, and produces design decisions.
npx claudepluginhub synaptiai/synapti-marketplace --plugin flowHow this command is triggered — by the user, by Claude, or both
Slash command
/flow:design feature-description-or-issue-numberThis command is limited to the following tools:
The summary Claude sees in its command listing — used to decide when to auto-load this command
<!-- PARALLEL EXECUTION RULE: When performing multiple independent operations, invoke ALL relevant tools simultaneously in a single message rather than sequentially. --> # Design: $ARGUMENTS Architecture discussion and design validation. Follows Explore > Plan > Review > Decide loop. ## Required Skills This command operates with these domain skills loaded: - `architecture-patterns` — C4 design, coupling analysis, decision framework - `capability-discovery` — detect available agents and tech stack ## Phase 1: EXPLORE Map existing architecture before proposing anything. Execute in paral...
/review-designReviews feature design documents for completeness, checks architecture, data models, and API contracts, identifies gaps, explores alternatives, and stores approved patterns.
/sc-workflowGuides feature development via phases: codebase exploration with agents, clarifying questions, architecture design, and step-by-step implementation.
/designDesigns system architecture, APIs, components, and databases producing specifications, diagrams, or code. Accepts target and optional --type (architecture|api|component|database) and --format flags.
/designGuides interactive frontend design workflow: project discovery, trend research, moodboard creation, color/typography selection, and production-ready code generation.
/designCreates comprehensive feature design documents with research and architecture for a given feature name or idea.
/designGenerates Markdown technical design document framework for a feature (doc mode, default). Also supports checklist mode for S-Tier SaaS design quality checks.
Share bugs, ideas, or general feedback.
Architecture discussion and design validation. Follows Explore > Plan > Review > Decide loop.
This command operates with these domain skills loaded:
architecture-patterns — C4 design, coupling analysis, decision frameworkcapability-discovery — detect available agents and tech stackMap existing architecture before proposing anything. Execute in parallel:
Parallel Bash calls:
# 1. Project structure
ls -la src/ app/ lib/ packages/ 2>/dev/null || ls -la
# 2. If issue number given, load issue context
ISSUE_NUM=$(echo "$ARGUMENTS" | grep -oE '[0-9]+')
[ -n "$ISSUE_NUM" ] && gh issue view $ISSUE_NUM --json title,body,labels
# 3. Current branch context
git branch --show-current
git log --oneline -5
Parallel Agent + Skill calls:
Agent(Explore):
"Analyze the architecture of this project. Find:
1. Entry points (main files, route definitions, controllers)
2. Dependency structure (imports between modules)
3. Existing design patterns (MVC, service layers, event-driven, etc.)
4. Code related to: $ARGUMENTS
Report: module map, dependency direction, patterns found."
Skill(capability-discovery):
Discover tech stack, available agents, and project conventions.
Map user flows (from architecture-patterns skill):
Create tasks to track each design activity:
TaskCreate("Map existing architecture", "Identify entry points, dependency structure, existing patterns relevant to $ARGUMENTS")
TaskCreate("Identify abstraction level", "Determine C4 level: Context, Containers, Components, or Code")
TaskCreate("Propose design", "Map components, dependencies, data flow, integration points, API surface")
TaskCreate("Coupling and convention review", "Check circular deps, god objects, dependency direction, convention alignment")
TaskCreate("Design decision", "Present trade-offs, get user approval, log to decision journal")
TaskUpdate("Map existing architecture", status: "in_progress")
Apply C4 model thinking at the appropriate level:
TaskUpdate("Map existing architecture", status: "completed") TaskUpdate("Identify abstraction level", status: "completed") TaskUpdate("Propose design", status: "in_progress")
Present the design proposal to the user. Use the decision framework from architecture-patterns:
| Field | Content |
|---|---|
| Context | {situation and forces} |
| Options | {2-4 approaches} |
| Trade-offs | {per-option analysis} |
| Recommendation | {preferred option and why} |
TaskUpdate("Propose design", status: "completed")
TaskUpdate("Coupling and convention review", status: "in_progress")
Validate the design with evidence:
Coupling check:
Agent(Explore):
"Check coupling and dependency health for this project:
1. Find circular dependencies
2. Identify god objects (files imported by many others)
3. Check dependency direction (does domain depend on infrastructure?)
4. Flag hidden coupling (shared mutable state, globals)
Report: coupling findings with file:line citations."
Convention alignment:
Present trade-offs to the user:
TaskUpdate("Coupling and convention review", status: "completed")
TaskUpdate("Design decision", status: "in_progress")
Use the AskUserQuestion tool with contextual options to ask: "Recommended design: {approach}. {rationale}. Approve?" 2. Log decision to decision journal if on a feature branch:
BRANCH=$(git branch --show-current)
ISSUE_NUM=$(echo "$BRANCH" | grep -oE 'issue-[0-9]+' | grep -oE '[0-9]+')
JOURNAL_DIR=".decisions"
[ -n "$ISSUE_NUM" ] && [ -d "$JOURNAL_DIR" ] && cat >> "$JOURNAL_DIR/issue-$ISSUE_NUM.md" << 'ENTRY'
## Design Decision: {title}
**Date**: {YYYY-MM-DD} | **Category**: architecture
**Decision**: {what was decided}
**Rationale**: {why this approach}
**Consequences**: {what changes, new constraints}
ENTRY
Present next steps:
/flow:start <issue> — begin implementation/flow:brainstorm — explore more options before deciding