architecture
npx machina-cli add skill vudovn/antigravity-kit/architecture --openclawArchitecture Decision Framework
"Requirements drive architecture. Trade-offs inform decisions. ADRs capture rationale."
🎯 Selective Reading Rule
Read ONLY files relevant to the request! Check the content map, find what you need.
| File | Description | When to Read |
|---|---|---|
context-discovery.md | Questions to ask, project classification | Starting architecture design |
trade-off-analysis.md | ADR templates, trade-off framework | Documenting decisions |
pattern-selection.md | Decision trees, anti-patterns | Choosing patterns |
examples.md | MVP, SaaS, Enterprise examples | Reference implementations |
patterns-reference.md | Quick lookup for patterns | Pattern comparison |
🔗 Related Skills
| Skill | Use For |
|---|---|
@[skills/database-design] | Database schema design |
@[skills/api-patterns] | API design patterns |
@[skills/deployment-procedures] | Deployment architecture |
Core Principle
"Simplicity is the ultimate sophistication."
- Start simple
- Add complexity ONLY when proven necessary
- You can always add patterns later
- Removing complexity is MUCH harder than adding it
Validation Checklist
Before finalizing architecture:
- Requirements clearly understood
- Constraints identified
- Each decision has trade-off analysis
- Simpler alternatives considered
- ADRs written for significant decisions
- Team expertise matches chosen patterns
Source
git clone https://github.com/vudovn/antigravity-kit/blob/main/.agent/skills/architecture/SKILL.mdView on GitHub Overview
This skill provides a structured approach to making architecture decisions. It centers on requirements analysis, trade-off evaluation, and ADR documentation to capture rationale and ensure traceability across design choices.
How This Skill Works
It guides you through a selective reading of relevant content (context-discovery, trade-off-analysis, pattern-selection, examples) to map the decision scope. You perform requirements gathering, run structured trade-off analyses using ADR templates, and document conclusions as ADRs. This creates a traceable, justifiable architectural record.
When to Use It
- Starting a new architecture design project.
- Comparing design options against requirements and constraints.
- Documenting decisions with ADRs for major architectural choices.
- Selecting patterns and anti-patterns through decision trees.
- Evaluating deployment, scalability, and maintainability trade-offs.
Quick Start
- Step 1: Identify requirements, constraints, and success criteria.
- Step 2: Run a trade-off analysis using ADR templates and capture decisions.
- Step 3: Publish ADRs and review with the team.
Best Practices
- Define and validate requirements and constraints before evaluating options.
- Use structured trade-off analyses and ADR templates for comparisons.
- Capture rationale in ADRs and commit them to version control.
- Read only files relevant to the request (context-discovery.md, trade-off-analysis.md) to keep scope focused.
- Start simple and defer added complexity until proven necessary.
Example Use Cases
- Choosing between monolithic vs microservices architecture for a SaaS product.
- Deciding on a database design approach (SQL vs NoSQL) during MVP.
- Documenting deployment strategy and rollback plans with ADRs.
- Selecting caching and failover patterns for a scalable API.
- Pattern comparison for API design (REST vs gRPC) in an enterprise app.
