Software Architecture

Reviewed 2026-10-15codingPrompt / Rule# architecture # adr # design-patterns # trade-offs # system-design

Community skill that gives an agent a simplicity-first method for architecture decisions: ask context questions, pick patterns with decision trees, and record the choice as an ADR.

Security Reviewed

Markdown-only guide with decision trees and ADR templates; nothing to run, no network, no keys.

Install Software Architecture in Google Antigravity

Antigravity loads skills from .agents/skills/ in your project or ~/.gemini/config/skills/ for all projects (official docs). Full guide

EasiestOption 1: paste this to your Antigravity agent

Install the "Software Architecture" skill for Google Antigravity.
Follow the steps at https://www.antigravityskills.org/install/architecture.md (source: https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/architecture).
Before running anything, show me what you will download and whether it includes scripts, and wait for my OK.
Install it into this project (.agents/skills/) unless I say global. When done, check that Antigravity lists it as an installed skill.

The agent reads the install file, shows you what it will download and waits for your OK.

Option 2: install it yourself

1. Download the repository
```
git clone --depth 1 https://github.com/sickn33/antigravity-awesome-skills.git /tmp/ag-skills && git -C /tmp/ag-skills log -1 --format=%h
```
We reviewed commit a307264. If the second command prints a different hash, the skill may have changed since our review.
2. Copy the skill into this project (workspace skill)
```
mkdir -p .agents/skills && cp -r /tmp/ag-skills/skills/architecture .agents/skills/
```
Run from your project root. Antigravity reads workspace skills from .agents/skills/<folder>/; this folder holds SKILL.md plus 5 reference files (6 files, no scripts).
3. Or install it for all projects (global skill)
```
mkdir -p ~/.gemini/config/skills && cp -r /tmp/ag-skills/skills/architecture ~/.gemini/config/skills/
```
Use this instead of the previous step. Copy only the skills you need: the repo README warns that a large watched skills folder can overload Antigravity's context.
4. Check that Antigravity sees it
Antigravity app: start a new conversation and ask "What skills do you have?"; architecture should be listed. Antigravity CLI: run /skills (/skills reload in a session that was already open).

The repository's own installer (npx agentic-awesome-skills --antigravity --skills <ids> --dry-run, README) can also install selected skills; the copy steps above use the standard Antigravity skill folders and install only this one.

Using Claude Code, Cursor or Codex? See other assistants below.

What is Software Architecture?

architecture is a community-contributed skill in sickn33's antigravity-awesome-skills collection. It is five short reference files behind a SKILL.md: context-discovery.md (questions to ask before suggesting anything), pattern-selection.md (a decision tree plus red flags), patterns-reference.md (when to use and when not to use 17 patterns), trade-off-analysis.md (decision and ADR templates) and examples.md (three worked examples from MVP to enterprise). The stance is one sentence repeated in three files: start simple and add complexity only when proven necessary.

How to use Software Architecture?

Install the skill, then describe the system you are designing. The agent should first ask about scale, team, timeline, domain and constraints (context-discovery.md), read only the file that matches the request (SKILL.md has a selective reading table), choose patterns with the decision tree, and write the decision up as an ADR under docs/architecture/.

Key features of Software Architecture

✓We counted at a307264: the folder has 6 Markdown files and no scripts: SKILL.md (65 lines, 2,205 bytes), context-discovery.md, examples.md, pattern-selection.md, patterns-reference.md and trade-off-analysis.md (12,750 bytes in total)
✓We counted: patterns-reference.md rates 17 patterns in four tables (4 data access, 4 domain logic, 5 distributed-system, 4 API), each with a "when to use", a "when NOT to use" and a complexity level
✓We counted: the decision tree in pattern-selection.md has 4 branches (data access, business rules, independent scaling, real-time) and says microservices are worth it only if all 3 conditions hold: clear domain boundaries, a team above 10 developers and different scaling needs; otherwise use a modular monolith
✓We counted: the ADR template has 4 status values (Proposed, Accepted, Deprecated, Superseded) and trade-off-analysis.md adds a "Revisit Trigger" field that asks when to reconsider the decision
✓We counted: examples.md walks through 3 cases (MVP e-commerce for a solo developer, SaaS with 5-10 developers, enterprise 100K+ users), each listing trade-offs accepted and a migration path
✓The skill's frontmatter says risk: safe, source: community, added 2026-02-27

When to use Software Architecture

1Choosing between a monolith, a modular monolith and microservices for a new product
2Writing an ADR so the reason for a technology choice is stored in the repo
3Reviewing whether a design has more patterns (Repository, CQRS, event sourcing) than the problem needs

Source and files

Repository: sickn33/antigravity-awesome-skills (MIT)
Upstream risk label: safe
Added upstream: 2026-02-27
SKILL.md size: 2.2 KB
Files in the skill folder: SKILL.md · context-discovery.md · examples.md · pattern-selection.md · patterns-reference.md · trade-off-analysis.md
Listing synced: 2026-10-05 from commit bdacd76

Installation & Setup Guide

Agent Rules / Prompt Setup

Follow these steps (taken from the project's own docs) to configure Software Architecture in your development environment.

Step 1: Claude Code (manual copy)claude

mkdir -p .claude/skills && cp -r /tmp/ag-skills/skills/architecture .claude/skills/

Not documented per skill by the repository; this uses Claude Code's standard .claude/skills/ folder after the clone above.

Step 2: Cursor: not documented by the projectcursor

The README lists installer targets for several hosts, but gives no per-skill Cursor path, so we do not list one.

Usage Example & Verification

Prompt / Request Example

1) SKILL.md usage: the agent reads only the file that matches the request, for example trade-off-analysis.md when documenting a decision (selective reading table in SKILL.md).

2) Our example: "Use the architecture skill. We are two developers building a booking app for about 500 users. Ask me the context questions first, then recommend an app structure and list what we should not build yet."
-> The agent asks about scale, team, timeline, domain and constraints, then applies the decision tree; for this size it should land on the simple end (monolith, ORM directly).

3) Our example: "Write an ADR for choosing PostgreSQL over MongoDB for our orders, using the skill's template."
-> The agent fills Context, Decision, Rationale, Trade-offs and Consequences and suggests saving it as docs/architecture/adr-002-postgresql-over-mongodb.md, the naming shown in the skill.

Security Review

Static review

Reviewed Date

2026-10-15

Audited Ref / Commit

a3072641b750a1fb2f6ce695a5f984ea3d4c3ec1

Reviewer

antigravityskills.org (static review)

Markdown-only guide with decision trees and ADR templates; nothing to run, no network, no keys.

Full review: scope, findings, risks

Audit Scope:SKILL.md, context-discovery.md, pattern-selection.md, patterns-reference.md, trade-off-analysis.md and examples.md read in full; repository README install and disclaimer sections and LICENSE, all at commit a307264 (2026-10-15). Static review only; nothing was executed.

Key Findings:Instruction-only skill. Six Markdown files; the only code blocks are YAML, Markdown templates and ASCII decision trees. No executable files, no commands for the agent to run, no URLs fetched, no credentials needed.

Identified Operational Risks & Permissions:Low. Advice quality depends on the model and on how well you describe your constraints; the thresholds are rules of thumb.

All six files were read for commands, URLs, file operations and credential handling. We found none: the fenced blocks are YAML examples, ASCII diagrams and Markdown templates. The only file the workflow tells the agent to create is an ADR under docs/architecture/, and only when you ask for documentation. This is a read of the text, not a behaviour test.

Operational Notes & Known Limitations

Known Limitations

•It gives opinionated defaults, not facts about your system: the thresholds (for example team above 10 for microservices) are the author's rules of thumb, not a standard
•The examples name specific products (Next.js, NestJS, Kafka, Kong, Istio); treat them as illustrations
•SKILL.md links three sibling skills (@[skills/database-design], @[skills/api-patterns], @[skills/deployment-procedures]); they are separate folders in the repo and are not copied by the steps above
•The skill's own Limitations section says output is not a substitute for environment-specific validation or expert review

Frequently Asked Questions

Is the Software Architecture skill safe?

It is six Markdown files. We read all of them and found no scripts, no commands to run, no network calls, no file writes by the skill itself and no API keys. The agent may create ADR files in your repo if you ask it to.

How do I install Software Architecture in Antigravity?

Clone sickn33/antigravity-awesome-skills, copy skills/architecture into .agents/skills/ (or ~/.gemini/config/skills/), then ask "What skills do you have?" (Antigravity CLI: /skills). The project README documents its own installer for selected skills.

Does it pick an architecture for me?

It guides the choice: it asks context questions, applies a decision tree and asks for trade-offs in writing. The decision stays yours.

What does it recommend for small teams?

Its examples favour a monolith for a solo developer and a modular monolith for 5-10 developers, and it lists microservices as a later step when its three conditions are met.

Is it an official Google skill?

No. It is community-contributed to an independent collection whose README says it is not affiliated with or endorsed by Google.

Supported Platforms

antigravityclaude

View Source on GitHub

Keep exploring this topic

Browse the full Antigravity skills directory for more source-linked skills with install steps and static safety reviews.

More coding skills #architecture #adr #design-patterns #trade-offs Use cases

Related Skills

💻

Clean Code

@sickn33

A one-file Clean Code playbook (Robert C. Martin's rules on naming, functions, comments, errors, tests and classes) that AI coding agents follow when writing, reviewing or refactoring code.

Tested in AntigravityStatic reviewinstructions onlyoffline

codingclean-code

✍️

Technical Writing

@anthropics

Anthropic's doc-coauthoring skill: a three-stage workflow in which the agent interviews you, drafts a spec or design doc section by section, then tests it on a fresh reader.

Static reviewwrites filesinstructions only

technical-writingdocumentation

💻

Performance Optimization

@sickn33

Community skill that gives an agent a measure-first workflow for slow apps: baseline, find the bottleneck, fix one anti-pattern, re-measure, and guard with a budget.

Static reviewinstructions onlyoffline

performancecore-web-vitals