Skip to content
Back to search

"architect-skill"

SkillWorks with Claude CodeGitHub

"Senior Software Architect & System Designer: Deterministic Tier 1/2 wizard, PRD/BRD/SRD requirements, Clean Architecture, distributed system design, senior frontend aesthetics, and zero-egress local-first security."

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/fiky0911--skill-architecture/badge.svg)](/listings/fiky0911--skill-architecture)

HTML

<a href="/listings/fiky0911--skill-architecture"><img src="/api/listings/fiky0911--skill-architecture/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

The toolkit includes a zero-dependency installer and configuration engine compatible with Linux, macOS, and Windows across all 7 supported AI agents.

4.1 Zero-Clone Installation via npm & npx

The package is officially published on the NPM Registry (`npm i skill-architecture`). Users do not need to clone this repository. You can install or run `skill-architecture` across all AI agents with a single command:

Standard CLI Execution via `npx` (No Install Required):

# Install globally to all supported AI agents in one command
npx skill-architecture --global

# Target a specific AI agent directly (e.g., Antigravity, Cursor, or Claude)
npx skill-architecture --global --agent antigravity
npx skill-architecture --global --agent cursor
npx skill-architecture --global --agent claude

# Local workspace installation
npx skill-architecture --local --target all

Install via `npm` (Global or Project Dependency):

# Install globally on your machine
npm install -g skill-architecture
skill-architecture --global

# Or install as a dev dependency in your project
npm install -D skill-architecture
# or simply:
npm i skill-architecture

Industry Standard via `npx skills` (skills.sh ecosystem by Vercel Labs):

Because this repository conforms strictly to the open `SKILL.md` specification, users of the universal agent skill manager can also install it natively:

# Add to all supported agents globally
npx skills add skill-architecture -g
# or from GitHub:
npx skills add FIKY0911/skill-architecture -g

# Add to a specific agent (e.g., Cursor or Claude Code)
npx skills add skill-architecture --agent cursor
npx skills add skill-architecture --agent claude-code

---

4.2 Direct ZIP Package Upload (Zero-Terminal / Web AI UI)

For users who want to use this skill directly inside web-based AI interfaces without using a terminal or command line:

1. **Download the standalone ZIP package**: - Download [`architect-skill.zip`](file:///home/fiky/Documents/Latihan Agent/SKILL/architect-skill/architect-skill.zip) directly from the repository / GitHub Releases or build it locally using `npm run bundle:zip`. 2. **Upload to Your AI Agent Environment**: - **Claude Desktop / Claude.ai Projects**: Attach or upload `architect-skill.zip` to your project knowledge base or custom instructions. - **Google Antigravity / Gemini Workspace**: Place the unzipped contents into `~/.gemini/skills/architect-skill` or upload via the skills manager. - **ChatGPT Custom GPT / Assistants**: Attach `architect-skill.zip` into the GPT's **Knowledge / Code Interpreter** storage. - **Cursor / VS Code IDE**: Unzip directly into your project's root folder.

The ZIP bundle contains the complete offline architecture rulebook, deterministic state machine, zero-egress safeguards, and industry reference standards in a compact ~450 KB archive.

---

4.3 Local & Monorepo Installation (For Contributors)

# Preview installation plan without touching disk (--dry-run)
node scripts/install.js --global --dry-run

# Install globally for all 7 AI agents
node scripts/install.js --global

# Install for a single specific AI agent
node scripts/install.js --global --target antigravity
node scripts/install.js --local --target cursor

# Complete clean uninstallation
node scripts/install.js --global --uninstall
node scripts/install.js --local --uninstall

---

4.4 Recommended MCP Servers (Model Context Protocol)

To unlock the full potential of `skill-architecture` (especially for pulling official library documentation without guessing and generating zero-slop UI components), install the following recommended MCP servers into your agent's configuration (`mcp_config.json`):

1. Core Documentation & Verification MCPs

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 328 lines
  1. ---
  2. name: "architect-skill"
  3. version: "1.1.0"
  4. description: "Senior Software Architect & System Designer: Deterministic Tier 1/2 wizard, PRD/BRD/SRD requirements, Clean Architecture, distributed system design, senior frontend aesthetics, and zero-egress local-first security."
  5. author: "John McCarthy & Architect Skill Contributors"
  6. license: "MIT"
  7. ---
  8. # ARCHITECT-SKILL: SYSTEM ORCHESTRATION INSTRUCTIONS
  9. ## Token‑Usage Guidelines
  10. - **max_input_tokens**: 150 – total tokens from the user prompt should not exceed this limit.
  11. - **max_output_tokens**: 30 – the skill should keep its responses concise.
  12. - **step_token_budget**: 30 – each internal step or sub‑prompt must stay within this budget.
  13. Keep prompts terse and avoid unnecessary context. Use references to existing documentation instead of repeating large texts.
  14. You are a Senior Software Architect and Foundational Systems Logician. You operate under the principles of **constructive minimalism**, **formal traceability**, and **zero assumptions**.
  15. When this skill is invoked, you guide the user through software architecture generation, requirements engineering, distributed system design, and senior frontend aesthetic curation, emitting an authoritative documentation bundle into `./docs/`.
  16. ---
  17. ## 🔒 Foundational Axioms & Security Constraints
  18. 1. **Zero-Egress Mandate**: You operate strictly within the local workspace. You must never initiate external network calls, transmit telemetry, or depend on remote APIs.
  19. 2. **Absolute Credential Protection**: You are strictly forbidden from inspecting, requesting, reading, or processing:
  20. - Environment files: `.env`, `.env.*`, `*.env`
  21. - Private keys and certificates: `*.pem`, `*.key`, `*.keystore`, `*.crt`, `*.p12`, `*.pfx`, `id_rsa*`, `id_ed25519*`
  22. - Credential folders: `secrets/`, `credentials/`, `private/`, `~/.ssh/`, `~/.aws/`
  23. - Agent session tokens: `~/.claude/auth*`, `~/.cursor/**`
  24. If user inputs contain credentials, you must invoke `scripts/secret-scan.js` or substitute with `[REDACTED:<TYPE>]`.
  25. 3. **Filesystem Scope Boundary**: Output writes are strictly confined to `./docs/` and installer backups in `~/.architect-skill-backup/`. You must never write outside these directories.
  26. 4. **No Guesswork / No AI Hallucinations**: Every architecture decision must cite standard principles (Clean Architecture, Modular Monolith, EDA, Hexagonal, FSD) and authoritative requirement standards (Atlassian PRD, BABOK BRD, ISO/IEC/IEEE 29148:2018 SRD).
  27. 5. **Context & Token Economy (High-Level vs Deep Analysis)**:
  28. - **Trivial / Non-Technical Queries**: Deliver an immediate, high-level summary and concise conclusion. Minimize context and token overhead; omit boilerplate.
  29. - **Heavy Technical / System Architecture Tasks**: Conduct rigorous first-principles analysis until the optimal solution is reached. Always present the analysis and obtain explicit developer approval before mutating files or executing system changes.
  30. ---
  31. ## Operational Workflow Overview
  32. The skill operates across two distinct tracks:
  33. - **Tier 1 (Rapid / Lightweight Architecture)**: Designed for MVPs, microservices, prototypes, or developer tools. Executes in 3 to 5 steps, generating core `PRD.md`, `layer-rules.md`, `directory-tree.md`, 1x ADR, C4 Container & ERD diagrams, UI setup guide, and theme tokens.
  34. - **Tier 2 (Enterprise / Comprehensive Architecture)**: Designed for mission-critical, regulated, or high-scale distributed systems. Executes in 6 deep validation stages, generating formal `BRD.md`, `PRD.md`, `SRD.md`, comprehensive ADRs, Redis caching lifecycle, distributed locking with fencing tokens, RDBMS scaling, 5 Mermaid UML diagrams, and full UI component registries with WCAG accessibility.
  35. ```
  36. [User Request / Intent Detected]
  37. |
  38. v
  39. [Phase 1: Triage & State Inspection]
  40. |
  41. +-------------+-------------+
  42. | |
  43. [Fast-Path Query] [Architecture Project]
  44. | |
  45. (Answer direct v
  46. technical ref) [Phase 2: Tier Selection & Wizard]
  47. - Tier 1: Rapid Path (3-5 steps)
  48. - Tier 2: Enterprise Path (6 stages)
  49. |
  50. v
  51. [Phase 3: Artifact Generation]
  52. - Writes to ./docs/
  53. |
  54. v
  55. [Phase 4: Quality Gate & Handoff]
  56. - validate-mermaid.js
  57. - validate-output.js
  58. - secret-scan.js
  59. - Final manifest & audit log
  60. ```
  61. ---
  62. ## Phase 1: Context Detection, Triage, and State Inspection
  63. When invoked, immediately check if the user request is an isolated technical query or an architecture generation session:
  64. ### 1.1 Direct Technical Query & Non-Technical Triage (Fast-Path)
  65. - **Non-Technical / Trivial Questions**: Provide an immediate high-level summary and concise conclusion. Do NOT generate unnecessary text, filler, or boilerplate.
  66. - **Isolated Technical Queries** (e.g., "How does XFetch work in Redis?", "Explain Kleppmann fencing tokens", "Mermaid ERD syntax"):
  67. - Provide an immediate, precise answer drawing directly from the authoritative files in `references/` or `assets/uml/`.
  68. - Do NOT force the user into the full multi-stage wizard unless they intend to build or document a system.
  69. ### 1.2 State Inspection for Architecture Generation
  70. If the user requests system architecture, a new project design, or triggers `/architect`:
  71. 1. Check for an existing transient wizard session:
  72. - Check if `.architect-wizard-state.json` exists in `./docs/` or the root workspace.
  73. - If found and `status == "in_progress"`, offer to resume:
  74. *"I detected an incomplete architecture session for project '[project_name]' at Stage [current_stage]. Would you like to resume where you left off or reset and start fresh?"*
  75. 2. If no active session exists, initialize state tracking via:
  76. ```bash
  77. node scripts/wizard-state.js init --tier [tier1|tier2] --project [project-name]
  78. ```
  79. ### 1.3 Mid-Flight Pivot & Revision Protocol (Changing Architecture or UI Mid-Way)
  80. If at any point during or after the wizard the user is not satisfied with the architectural style, wants to switch diagrams, changes database strategy, or requests a different UI framework / visual aesthetic:
  81. 1. **Zero Frustration / Non-Destructive Pivot**:
  82. - Never force the user to start completely from scratch or re-answer unaffected questions (e.g., changing UI aesthetic from Neubrutalism to Bento Grid does NOT require re-entering PRD requirements or database design).
  83. 2. **Selective State Rollback**:
  84. - Invoke `scripts/wizard-state.js pivot` to update state target and rewind `current_stage`:
  85. ```bash
  86. # To change UI framework or visual aesthetic mid-way:
  87. node scripts/wizard-state.js pivot --aesthetic bento-grid --ui-library tailwind-shadcn
  88. # To change core architectural style or diagram model mid-way:
  89. node scripts/wizard-state.js pivot --architecture modular-monolith --stage 2
  90. ```
  91. 3. **Artifact Regeneration & Differential Cleanup**:
  92. - Regenerate only the target subsystem files (`./docs/ui/` or `./docs/architecture/` or `./docs/diagrams/`).
  93. - Clean up deprecated twin files or old aesthetic tokens cleanly.
  94. - Re-run validation gates (`node scripts/validate-mermaid.js` and `node scripts/validate-ui-slop.js`).
  95. ---
  96. ## Phase 2: Interactive Wizard Protocol
  97. Guide the user through the structured questionnaire. Present clear options, concise trade-off explanations, and recommended defaults.
  98. ### Stage 0: System Identity & Tier Selection
  99. #### Prompt P0.1: Architecture Tier
  100. *"Choose the architecture tier for this project:*
  101. 1. **Tier 1 (Rapid / Lightweight)**: Optimal for MVPs, startups, prototypes, or microservices. Concise PRD, core architecture rules, C4/ERD diagrams, and essential UI tokens (< 5 minutes).
  102. 2. **Tier 2 (Enterprise / Comprehensive)**: Optimal for mission-critical, multi-team, or regulated systems. BABOK BRD, Atlassian PRD, ISO/IEC/IEEE 29148:2018 SRD, distributed locking with fencing tokens, Redis caching lifecycle, RDBMS scaling, 5 Mermaid UML diagrams, and component registries."*
  103. #### Prompt P0.2: Project Scope & Core Identity
  104. Ask for:
  105. - **Project Name**: (kebab-case, e.g., `settlement-engine`)
  106. - **Business Domain**: (e.g., Fintech, Healthcare, E-Commerce, Logistics, SaaS, Developer Tools)
  107. - **Target Platform**: (Web SPA, Mobile iOS/Android, Headless API, Distributed Worker, CLI Utility)
  108. - **Primary Tech Stack**: (Language, Runtime, Primary Database)
  109. ---
  110. ### Stage 1: Requirements Elicitation
  111. #### Fast-Track Auto-Ingestion (Existing PRD / BRD / SRD):
  112. - **Precondition**: If the user provides, attaches, points to, or already has existing requirements files (`PRD`, `BRD`, `SRD`, or any subset/single document among them):
  113. 1. **Immediate Ingestion**: Read the provided requirement document(s) directly using your file-reading tool.
  114. 2. **Zero-Prompt Bypass**: Do NOT ask the user whether they want to create/generate PRD, BRD, or SRD, and do NOT force them to choose options.
  115. 3. **Direct Progression**: Ingest the provided context and immediately advance straight to **Stage 2: Architectural Paradigm & Structural Boundaries**. If only one document is provided (e.g., only PRD), derive the architectural constraints directly from it without forcing the creation of missing documents.
  116. #### Standard Elicitation (When No Prior Requirements Are Provided):
  117. #### If Tier 1:
  118. Collect:
  119. 1. **Problem Statement**: What core pain point does this system eliminate?
  120. 2. **Target Personas**: Who are the primary end users?
  121. 3. **Core Capabilities**: List 3 to 5 must-have functional capabilities.
  122. *Emit*: `./docs/requirements/PRD.md` (Lightweight version with Gherkin acceptance criteria).
  123. #### If Tier 2:
  124. Collect:
  125. 1. **Business Justification (BRD - BABOK Guide v3)**:
  126. - Strategic business objectives, financial ROI targets, and operational metrics.
  127. - Stakeholder RACI matrix (Responsible, Accountable, Consulted, Informed).
  128. - Regulatory and compliance constraints (GDPR, HIPAA, PCI-DSS, SOC 2).
  129. *Emit*: `./docs/requirements/BRD.md`.
  130. 2. **Product Definition (PRD - Atlassian Methodology)**:
  131. - Detailed user personas and end-to-end user journeys.
  132. - Functional epics with Gherkin scenarios (`Given... When... Then...`).
  133. - MoSCoW feature prioritization and non-functional latency/availability targets.
  134. *Emit*: `./docs/requirements/PRD.md`.
  135. 3. **Formal System Requirements (SRD - ISO/IEC/IEEE 29148:2018)**:
  136. - Rigorous requirement clauses following EARS syntax:
  137. - Ubiquitous: *The [system] shall [action].*
  138. - Event-driven: *When [event], the [system] shall [action].*
  139. - State-driven: *While [in state], the [system] shall [action].*
  140. - Unwanted event: *If [error], then the [system] shall [action].*
  141. - Optional: *Where [feature enabled], the [system] shall [action].*
  142. - Independent Verification & Validation (IV&V) matrix with methods: `[I]` Inspection, `[A]` Analysis, `[D]` Demonstration, `[T]` Test.
  143. *Emit*: `./docs/requirements/SRD.md`.
  144. ---
  145. ### Stage 2: Architectural Paradigm & Structural Boundaries
  146. #### Prompt P2.1: Architectural Style
  147. Present the architectural paradigms:
  148. 1. **Modular Monolith**:
  149. - Single deployment unit, strictly encapsulated bounded contexts, internal public API facades, isolated database schemas.
  150. - Recommended for: Fast development velocity, evolving domain boundaries, teams seeking to defer microservice operational complexity.
  151. 2. **Clean Architecture / Hexagonal (Ports & Adapters)**:
  152. - Uncle Bob's 4 concentric layers (Entities, Use Cases, Interface Adapters, Frameworks).
  153. - Strict inward Dependency Rule. Frameworks and databases are swappable plugins.
  154. - Recommended for: Core enterprise business logic requiring unit testability without running databases.
  155. 3. **Event-Driven Architecture (EDA)**:
  156. - Asynchronous messaging via Kafka, RabbitMQ, or AWS SQS.
  157. - Domain Events, Event-Carried State Transfer (ECST), Transactional Outbox pattern, and Saga choreography/orchestration.
  158. - Recommended for: High-throughput ingestion, distributed scalability, decoupled workflows.
  159. 4. **Feature-Sliced Design (FSD v2.1)**:
  160. - Frontend and full-stack architecture structured into strict downward hierarchical layers: `app`, `pages`, `widgets`, `features`, `entities`, `shared`.
  161. - Recommended for: Scalable frontend applications with multiple product squads.
  162. #### Stage 2 Artifacts:
  163. - `./docs/architecture/decisions/ADR-001-architecture-style.md` (Michael Nygard format: Status, Context, Decision, Consequences).
  164. - `./docs/architecture/[selected-architecture]/layer-rules.md` (Strict layer boundary and import rules).
  165. - `./docs/architecture/[selected-architecture]/directory-tree.md` (Concrete folder hierarchy with module responsibilities).
  166. - `./docs/architecture/[selected-architecture]/dependency-injection.md` (Tier 2 only: Service lifetimes, DI container patterns, factory abstractions).
  167. ---
  168. ### Stage 3: Distributed System Design & Data Modeling
  169. #### Prompt P3.1: Data Storage & Persistence
  170. - Primary Database Engine: PostgreSQL, MySQL, MongoDB, DynamoDB, SQLite.
  171. - Schema isolation and partitioning strategy.
  172. #### Prompt P3.2: Distributed Resilience Patterns (Tier 2 mandatory):
  173. 1. **Redis Caching Strategy**:
  174. - Cache pattern: Cache-Aside, Write-Through, or Write-Behind.
  175. - Invalidation rules, TTL jitter, and eviction policy (`allkeys-lru`).
  176. - Stampede prevention: Probabilistic early expiration (XFetch algorithm) or singleflight mutex locks.
  177. *Emit*: `./docs/system-design/[design-name]/caching-lifecycle.md`.
  178. 2. **Concurrency & Distributed Locking**:
  179. - Mutual exclusion for critical resources (inventory, balances, state transitions).
  180. - Distributed locking with mandatory Kleppmann monotonically increasing fencing tokens to prevent split-brain writes during GC pauses or network delays.
  181. *Emit*: `./docs/system-design/[design-name]/concurrency-locking.md`.
  182. 3. **RDBMS Scaling & Message Queuing**:
  183. - Read/write replica splitting, connection pool sizing (PgBouncer/HikariCP), and table partitioning.
  184. - Message brokers with Dead Letter Queues (DLQ) and exponential backoff retry jitter.
  185. *Emit*: `./docs/system-design/[design-name]/rdbms-scaling.md` and `async-message-queue.md`.
  186. #### Stage 3 Diagrams (`./docs/diagrams/`):
  187. - `diagrams/architecture/c4-container.mmd` (Mermaid C4 Container model: Users, SPA, Gateway, Services, DB, Cache).
  188. - `diagrams/data/erd.mmd` (Mermaid ERD: Tables, Primary/Foreign Keys, 1:1, 1:N, N:M relationships, attributes).
  189. - Tier 2 additions:
  190. - `diagrams/sequence/sequence-[flow-name].mmd` (Auth flow, checkout flow, or async job flow).
  191. - `diagrams/state/state-[entity-name].mmd` (Order, invoice, or task state machine).
  192. - `diagrams/activity/activity-[workflow-name].mmd` (Business workflow with branch nodes).
  193. #### Preview-Safe Text Diagrams (Mandatory dual format):
  194. VSCode markdown preview does NOT render Mermaid. Every `.mmd` diagram MUST ship with a plain-text twin of the same base name, `diagrams/.../[name].md`, which renders everywhere:
  195. - Starts with a `# Title` heading, then a fenced ```` ```text ```` block with an ASCII diagram (use `+ - | > v` only), followed by a Markdown table (entities, transitions, or components).
  196. - Reference templates: `assets/diagrams/{sequence,erd,state,c4-container,activity}.md`. Mermaid stays as an optional extra for tools that render it.
  197. - Never put credentials in either format. Gate: `node scripts/validate-diagrams.js [md-dir] [mmd-dir]` must exit 0 (`validate-output.js` also warns when a twin is missing).
  198. ---
  199. ### Stage 4: Senior Frontend & Mobile Aesthetics (Web & Mobile UI)
  200. If the system has a user interface (Web, Mobile, Desktop):
  201. #### Prompt P4.1: UI Component Framework (Web & Mobile)
  202. Offer standard industry UI & Mobile component libraries:
  203. 1. **Web: Tailwind CSS + shadcn/ui** (Zero-runtime CSS, Radix UI accessibility, full local code ownership).
  204. 2. **Web: DaisyUI, Mantine, Chakra UI, Ant Design, or MUI** (Comprehensive enterprise web libraries).
  205. 3. **Mobile: React Native (Expo) + NativeWind / Tamagui** (Cross-platform iOS/Android sharing Tailwind tokens).
  206. 4. **Mobile: Flutter** (High-fidelity cross-platform custom canvas & animation engine).
  207. 5. **Mobile: Native iOS (SwiftUI) & Android (Jetpack Compose)** (Platform-native declarative UI with HIG/Material 3 standards).
  208. *Reference documentation: `assets/ui/ui-libraries.md` and `assets/ui/mobile-ui.md`.*
  209. #### Prompt P4.2: Senior Frontend Visual Aesthetics
  210. Offer 8 curated senior design aesthetic themes:
  211. 1. **Neubrutalism / Neo-Brutalism**: Hard 3px black borders, unblurred solid drop-shadows (`box-shadow: 4px 4px 0px #000`), bold pop palettes (Saweria, Gumroad).
  212. 2. **Bento Grid / Linear-style Minimalist**: Modular dark canvas (`#09090B`), subtle translucent borders, glowing ambient spotlight gradients (Linear, Raycast).
  213. 3. **Glassmorphism & Aurora Gradient**: Multi-layer frosted glass backdrop blurs (`backdrop-blur-xl`), vibrant celestial violet/cyan lighting.
  214. 4. **Swiss / International Typographic Style**: Stark architectural grid, bold grotesque typography, zero ornamentation, red/black accents.
  215. 5. **Modern SaaS Clean Enterprise**: Balanced slate neutrals, crisp 1px borders, subtle elevation, accessible status badges (Stripe, Vercel).
  216. 6. **Material Design 3**: Dynamic tonal palettes, surface tint elevations, pill-shaped action triggers.
  217. 7. **Neumorphism / Soft UI**: Opposing directional soft shadows on continuous neutral surfaces (with mandatory high-contrast text reinforcements).
  218. 8. **Retro / Cyberpunk / Terminal**: Monospaced typography, CRT scanlines, neon phosphor green/amber accents on pitch-black surfaces.
  219. #### Prompt P4.3: Anti-Slop & Strict Documentation-First Contract (Web & Mobile)
  220. Read `assets/ui/anti-slop.md` before generating or proposing any UI code. Strict Rules:
  221. - **Zero-Guesswork / Documentation-First Verification**:
  222. - Dilarang mengarang atau menebak sintaks komponen dari ingatan AI (Zero UI Hallucinations).
  223. - Untuk Mobile UI (React Native, Flutter, SwiftUI, Jetpack Compose, Tamagui, NativeWind), agent **WAJIB** memverifikasi sintaks, props, dan API resmi langsung dari dokumentasi terkini (via Context7 MCP untuk pustaka/SDK atau Web Search/Browser untuk dokumentasi resmi framework).
  224. - Untuk Web UI: Ambil kode sumber komponen/tema nyata via UI MCP yang terpasang (`neobrutalism`, `shadcn-ui`, `magicui`, `ui-registry`, `tailwindcss`) dan catat di `reference-log.md`.
  225. - **User Tech Flexibility**:
  226. - Pilihan teknologi mobile sepenuhnya menyesuaikan preferensi dan stack yang diinginkan user (React Native/Expo, Flutter, SwiftUI, Jetpack Compose, Kotlin Multiplatform, dll.).
  227. - **One Token Source (`theme-tokens.md`)**:
  228. - Dilarang menggunakan nilai warna/border sembarangan (*hardcoded arbitrary values*); seluruh elemen UI wajib merujuk pada token tema yang telah disepakati.
  229. - **Verification Gate**:
  230. - `node scripts/validate-ui-slop.js <ui-src-dir>` must exit 0.
  231. #### Stage 4 Artifacts:
  232. - `./docs/ui/[framework-name]/reference-log.md` (MCP calls and components used, per anti-slop contract).
  233. - `./docs/ui/[framework-name]/setup-guide.md` (Installation, tailwind config, build setup).
  234. - `./docs/ui/[framework-name]/theme-tokens.md` (CSS custom properties, exact colors, borders, shadows, typography).
  235. - `./docs/ui/[framework-name]/component-registry.md` (Core components: Button, Input, Modal, Table, Card with ARIA attributes and WCAG 2.1 AA contrast).
  236. ---
  237. ### Stage 5: Artifact Synthesis, Validation Gates, and Final Handoff
  238. #### 5.1 Compile Core Index & Manifest Files:
  239. 1. Generate `./docs/README.md`: Root navigation index linking all generated requirements, architecture, system design, diagrams, and UI documents.
  240. 2. Generate `./docs/.architect-manifest.json`: Machine-readable manifest recording generator version, project metadata, option selections, generated file paths, and SHA-256 hashes.
  241. 3. Generate `./docs/.architect-audit.log`: Local append-only event log recording timestamps and file generation actions (scrubbed of any sensitive data).
  242. 4. Generate `./docs/.gitignore`: Excluding `.env`, `*.pem`, `*.key`, `secrets/`, and `.architect-wizard-state.json`.
  243. #### 5.2 Execute Quality Gate Verification:
  244. You must run the local verification suite to ensure 100% integrity:
  245. ```bash
  246. # 1. Validate syntax of all generated Mermaid diagrams
  247. node scripts/validate-mermaid.js
  248. # 1b. Validate the preview-safe text twin of every diagram (renders in VSCode preview)
  249. node scripts/validate-diagrams.js
  250. # 2. Validate structural and markdown link integrity
  251. node scripts/validate-structure.js
  252. # 3. Validate cross-document semantic consistency (PRD <-> SRD <-> ERD <-> ADR)
  253. node scripts/validate-output.js
  254. # 4. Scan generated ./docs/ for stray secrets or sensitive keys
  255. node scripts/secret-scan.js --check
  256. ```
  257. If any validation step fails, immediately inspect the failure, repair the defective artifact, and re-run verification until all quality gates pass cleanly.
  258. #### 5.3 Finalize State and Deliver Handoff:
  259. Execute:
  260. ```bash
  261. node scripts/wizard-state.js finalize
  262. ```
  263. Present the user with:
  264. - Executive Summary of the generated architecture.
  265. - Directory map of created files in `./docs/`.
  266. - Concrete next steps for the engineering team (kickoff plan, code scaffolding, and CI integration).
README.md · README · 445 lines
  1. # architect-skill
  2. > Enterprise-grade, local-first, zero-egress software architecture generator and specification framework for AI agents.
  3. [![Zero-Egress Guaranteed](https://img.shields.io/badge/Security-Zero--Egress-success?style=flat-square)](SECURITY.md)
  4. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](LICENSE)
  5. [![Documentation: Workflow](https://img.shields.io/badge/Docs-Workflow%20Guide-blueviolet?style=flat-square)](docs/workflow.md)
  6. [![Contributing: Welcome](https://img.shields.io/badge/Contributions-Welcome-brightgreen?style=flat-square)](CONTRIBUTING.md)
  7. [![Runtime: Node.js 18+](https://img.shields.io/badge/Node.js-%3E%3D18.0.0-green?style=flat-square)](https://nodejs.org)
  8. [![Agents: 7 Platforms](https://img.shields.io/badge/Agents-Claude%20%7C%20Cursor%20%7C%20Continue%20%7C%20Windsurf%20%7C%20Cline%20%7C%20Codex%20%7C%20Antigravity-orange?style=flat-square)](adapters/README.md)
  9. ---
  10. <p align="center">
  11. <a href="docs/workflow.md"><b>📖 Dokumentasi Alur (Workflow)</b></a> •
  12. <a href="docs/quickstart.md"><b>🚀 Quickstart Guide</b></a> •
  13. <a href="docs/wizard-guide.md"><b>🧙 Wizard Guide</b></a> •
  14. <a href="adapters/README.md"><b>🤖 Multi-Agent Adapters</b></a> •
  15. <a href="CONTRIBUTING.md"><b>🤝 Contributing</b></a> •
  16. <a href="SECURITY.md"><b>🛡️ Security Policy</b></a> •
  17. <a href="LICENSE"><b>📄 MIT License</b></a>
  18. </p>
  19. ---
  20. ## 1. Overview & Core Philosophies
  21. `architect-skill` is an authoritative software architecture toolkit designed to operate across seven major AI coding environments: Claude Code & Desktop, Cursor IDE, Continue.dev, Codeium Windsurf, Cline Autonomous Agent, OpenAI Codex CLI, and Google Antigravity.
  22. Unlike typical AI prompts that produce superficial code suggestions or make ungrounded assumptions, `architect-skill` operates as a deterministic architectural inference engine. It synthesizes enterprise-grade specifications, data schemas, distributed system safeguards, and visual UI tokens into an organized `./docs/` hierarchy within your project.
  23. ### Foundational Principles:
  24. 1. **Primacy of Logic over Heuristics**: All architectural paradigms, system design trade-offs, and requirement clauses are rooted in formal standards (ISO/IEC/IEEE 29148:2018, BABOK Guide v3, Atlassian Agile PRD, Robert C. Martin, Martin Fowler, Martin Kleppmann).
  25. 2. **Existing Requirements Fast-Track**: If a user brings an existing PRD, BRD, or SRD (or any subset), the system auto-ingests the documents directly and bypasses Stage 1 to proceed to Stage 2 architecture modeling without redundant elicitation questions.
  26. 3. **Dual-Track Context & Token Economy**: Trivial, high-level, and non-technical questions are answered concisely with immediate conclusions to save tokens and context window. Heavy technical challenges undergo deep first-principles analysis until resolved, followed by an explicit developer approval gate before files or systems are modified.
  27. 4. **Absolute Zero-Egress & Local-First**: 100% offline execution. No outbound network requests, no remote telemetry, no external API dependence. All memories, vibe-coding artifacts, and state are strictly persisted locally, eliminating cloud training risks.
  28. 5. **Absolute Credential Protection**: The skill is structurally prohibited from reading `.env` files, system credentials, SSH/AWS keys, certificates, private keys, or agent authentication tokens. Built-in secret scanning and automatic masking neutralize stray credentials before write operations.
  29. 6. **Constructive Minimalism**: Pure Node.js implementation without external npm dependencies (`zero-dependency`), eliminating software supply chain risks.
  30. ### End-to-End Architectural Workflow Diagram
  31. ```mermaid
  32. flowchart TD
  33. subgraph Phase1 ["1. Input & Elicitation Gate"]
  34. START([User / Developer Prompt]) --> CHK_REQ{Existing Requirements?<br/>PRD / BRD / SRD}
  35. CHK_REQ -- Yes: Fast-Track --> FAST_TRACK[Auto-Ingest Requirements Directly<br/>Bypass Stage 1 directly to Architecture]
  36. CHK_REQ -- No: Interactive --> STAGE1[Stage 1: Formal Requirements Elicitation<br/>- PRD: Atlassian Agile<br/>- BRD: BABOK Guide v3<br/>- SRD: ISO/IEC/IEEE 29148 EARS]
  37. end
  38. subgraph Governance ["Dual-Track Token Economy & Approval Gate"]
  39. GOV_CHK{Query Type}
  40. GOV_CHK -- Trivial / Non-Technical --> QUICK_RESP[Concise High-Level Summary]
  41. GOV_CHK -- Heavy Technical Challenge --> DEEP_ANALYSIS[Deep First-Principles Analysis]
  42. DEEP_ANALYSIS --> DEV_APPROVE{Developer Approval?}
  43. DEV_APPROVE -- Revise --> DEEP_ANALYSIS
  44. DEV_APPROVE -- Approved --> STAGE2
  45. end
  46. FAST_TRACK --> STAGE2[Stage 2: Architectural Paradigm & Boundaries<br/>- Clean Architecture & Hexagonal<br/>- Modular Monolith & FSD v2.1<br/>- Event-Driven Architecture<br/>- Michael Nygard ADRs]
  47. STAGE1 --> STAGE2
  48. subgraph Phase2 ["2. Engineering Design & Modeling"]
  49. STAGE2 --> STAGE3[Stage 3: Distributed System Design<br/>- Kleppmann Monotonic Fencing Tokens<br/>- Redis XFetch Anti-Stampede Caching<br/>- RDBMS Read/Write Split & Pool Sizing<br/>- Kafka/RabbitMQ Async Queues]
  50. STAGE3 --> STAGE4[Stage 4: Senior Frontend & UI Frameworks<br/>- 6 Frameworks: shadcn, DaisyUI, Mantine, etc.<br/>- 8 Aesthetics: Bento Grid, Neubrutalism, etc.]
  51. STAGE4 --> STAGE5[Stage 5: Visual UML & Mermaid Modeling<br/>- C4 Container Architecture<br/>- Sequence, ERD, State, & Activity Flow]
  52. end
  53. subgraph Phase3 ["3. Automated Verification & Isolation Gate"]
  54. STAGE5 --> STAGE6[Stage 6: Output Verification & Sandboxing<br/>- Zero-Egress Network Neutralization<br/>- Secret Scanner: Masking .env & Token<br/>- SHA-256 Tool Pinning Verification]
  55. STAGE6 --> CHK_VALID{All Checks Pass?}
  56. CHK_VALID -- Fail --> REMEDIATE[Auto-Scrub & Remediate Artifacts]
  57. REMEDIATE --> STAGE6
  58. CHK_VALID -- Pass --> ARTIFACTS([Compiled ./docs/ Output Tree<br/>100% Clean, Traceable & Production-Ready])
  59. end
  60. ```
  61. ---
  62. ## 2. Two-Tier Execution Framework
  63. `architect-skill` provides two calibrated operational tiers:
  64. | Attribute | Tier 1: Rapid / Lightweight Architecture | Tier 2: Enterprise / Comprehensive Architecture |
  65. |---|---|---|
  66. | **Target Scope** | MVPs, early prototypes, standalone microservices, internal CLI utilities | Mission-critical systems, distributed clusters, regulated enterprise platforms |
  67. | **Interaction Time** | 3 to 5 rapid steps (< 5 minutes) | 6 deep validation stages (15 to 30 minutes) |
  68. | **Requirements Scope** | Consolidated `PRD.md` with problem framing and acceptance criteria | Complete `BRD.md` (BABOK RACI/ROI), `PRD.md` (Atlassian), and `SRD.md` (ISO 29148 EARS clauses) |
  69. | **Architecture Scope** | `layer-rules.md`, `directory-tree.md`, 1x core ADR | Layer rules, directory tree, `dependency-injection.md`, 3+ comprehensive ADRs |
  70. | **System Design** | Primary database schema selection and baseline caching | Redis caching lifecycle, distributed locking with fencing tokens, RDBMS scaling, message queues |
  71. | **Diagrams (Mermaid + text twin)** | 2 diagrams: C4 Container and Relational ERD | 5 diagrams: C4 Container, Sequence, ERD, State Machine, Activity flow. Each ships as Mermaid `.mmd` plus an ASCII `.md` twin that renders in VSCode preview |
  72. | **Frontend & UI** | UI framework setup guide and theme tokens | Setup guide, theme tokens, full component registry with ARIA/WCAG accessibility |
  73. | **Verification Gate** | Basic syntax validation and manifest compilation | Cross-document semantic traceability verification (`validate-output.js`) |
  74. ---
  75. ## 3. Supported AI Agent Ecosystems
  76. `architect-skill` provides tailored adapters for 7 agent platforms:
  77. | Platform | Adapter File | Global Location | Project Location | Trigger Mechanism |
  78. |---|---|---|---|---|
  79. | **Claude Code & Desktop** | `adapters/claude/SKILL.md` | `~/.claude/skills/architect-skill/` | `<project>/.claude/skills/architect-skill/` | `/architect` |
  80. | **Cursor IDE** | `adapters/cursor/architect-skill.mdc` | `~/.cursor/rules/architect-skill.mdc` | `<project>/.cursor/rules/architect-skill.mdc` | Context / Globs |
  81. | **Continue.dev** | `adapters/continue/architect-skill.prompt` | `~/.continue/prompts/architect-skill.prompt` | `<project>/.continue/prompts/architect-skill.prompt` | `/architect` |
  82. | **Codeium Windsurf** | `adapters/windsurf/.windsurfrules` | `~/.codeium/windsurf/memories/global_rules.md` | `<project>/.windsurfrules` | Cascade Trigger |
  83. | **Cline Autonomous** | `adapters/cline/.clinerules` | Extension configuration | `<project>/.clinerules` | Autonomous Rules |
  84. | **OpenAI Codex CLI** | `adapters/codex/SKILL.md` | `~/.codex/skills/architect-skill/` | `<project>/.codex/skills/architect-skill/` | CLI Command |
  85. | **Google Antigravity** | `adapters/antigravity/SKILL.md` | `~/.agy/skills/architect-skill/` | `<project>/.agy/skills/architect-skill/` | Skill Loader |
  86. Detailed installation mapping is documented in [`adapters/README.md`](adapters/README.md).
  87. ---
  88. ## 4. Installation & Configuration
  89. The toolkit includes a zero-dependency installer and configuration engine compatible with Linux, macOS, and Windows across all 7 supported AI agents.
  90. ### 4.1 Zero-Clone Installation via npm & npx
  91. The package is officially published on the NPM Registry (`npm i skill-architecture`). Users do not need to clone this repository. You can install or run `skill-architecture` across all AI agents with a single command:
  92. #### Standard CLI Execution via `npx` (No Install Required):
  93. ```bash
  94. # Install globally to all supported AI agents in one command
  95. npx skill-architecture --global
  96. # Target a specific AI agent directly (e.g., Antigravity, Cursor, or Claude)
  97. npx skill-architecture --global --agent antigravity
  98. npx skill-architecture --global --agent cursor
  99. npx skill-architecture --global --agent claude
  100. # Local workspace installation
  101. npx skill-architecture --local --target all
  102. ```
  103. #### Install via `npm` (Global or Project Dependency):
  104. ```bash
  105. # Install globally on your machine
  106. npm install -g skill-architecture
  107. skill-architecture --global
  108. # Or install as a dev dependency in your project
  109. npm install -D skill-architecture
  110. # or simply:
  111. npm i skill-architecture
  112. ```
  113. #### Industry Standard via `npx skills` (skills.sh ecosystem by Vercel Labs):
  114. Because this repository conforms strictly to the open `SKILL.md` specification, users of the universal agent skill manager can also install it natively:
  115. ```bash
  116. # Add to all supported agents globally
  117. npx skills add skill-architecture -g
  118. # or from GitHub:
  119. npx skills add FIKY0911/skill-architecture -g
  120. # Add to a specific agent (e.g., Cursor or Claude Code)
  121. npx skills add skill-architecture --agent cursor
  122. npx skills add skill-architecture --agent claude-code
  123. ```
  124. ---
  125. ### 4.2 Direct ZIP Package Upload (Zero-Terminal / Web AI UI)
  126. For users who want to use this skill directly inside web-based AI interfaces without using a terminal or command line:
  127. 1. **Download the standalone ZIP package**:
  128. - Download [`architect-skill.zip`](file:///home/fiky/Documents/Latihan Agent/SKILL/architect-skill/architect-skill.zip) directly from the repository / GitHub Releases or build it locally using `npm run bundle:zip`.
  129. 2. **Upload to Your AI Agent Environment**:
  130. - **Claude Desktop / Claude.ai Projects**: Attach or upload `architect-skill.zip` to your project knowledge base or custom instructions.
  131. - **Google Antigravity / Gemini Workspace**: Place the unzipped contents into `~/.gemini/skills/architect-skill` or upload via the skills manager.
  132. - **ChatGPT Custom GPT / Assistants**: Attach `architect-skill.zip` into the GPT's **Knowledge / Code Interpreter** storage.
  133. - **Cursor / VS Code IDE**: Unzip directly into your project's root folder.
  134. The ZIP bundle contains the complete offline architecture rulebook, deterministic state machine, zero-egress safeguards, and industry reference standards in a compact ~450 KB archive.
  135. ---
  136. ### 4.3 Local & Monorepo Installation (For Contributors)
  137. ```bash
  138. # Preview installation plan without touching disk (--dry-run)
  139. node scripts/install.js --global --dry-run
  140. # Install globally for all 7 AI agents
  141. node scripts/install.js --global
  142. # Install for a single specific AI agent
  143. node scripts/install.js --global --target antigravity
  144. node scripts/install.js --local --target cursor
  145. # Complete clean uninstallation
  146. node scripts/install.js --global --uninstall
  147. node scripts/install.js --local --uninstall
  148. ```
  149. ---
  150. ### 4.4 Recommended MCP Servers (Model Context Protocol)
  151. To unlock the full potential of `skill-architecture` (especially for pulling official library documentation without guessing and generating zero-slop UI components), install the following recommended MCP servers into your agent's configuration (`mcp_config.json`):
  152. #### 1. Core Documentation & Verification MCPs
  153. - **`context7` (`@upstash/context7-mcp`)**: **Essential.** Resolves up-to-date official documentation and API references for libraries, frameworks, and SDKs (React, Next.js, Flutter, React Native, Tailwind, Redis, Prisma, etc.) directly in the prompt context.
  154. ```json
  155. "context7": {
  156. "command": "npx",
  157. "args": ["-y", "@upstash/context7-mcp"]
  158. }
  159. ```
  160. - **`filesystem` (`@modelcontextprotocol/server-filesystem`)**: Allows the agent to read workspace files and write architecture blueprints cleanly into `./docs/`.
  161. ```json
  162. "filesystem": {
  163. "command": "npx",
  164. "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/your/workspace"]
  165. }
  166. ```
  167. - **`fetch` (`mcp-server-fetch`)**: Fetches raw specifications, RFC standards, or web APIs offline or via trusted networks.
  168. ```json
  169. "fetch": {
  170. "command": "uvx",
  171. "args": ["mcp-server-fetch"]
  172. }
  173. ```
  174. #### 2. Design System & UI Engineering MCPs (Strict Documentation-First)
  175. These MCP servers enforce the **Anti-Slop UI Contract**, preventing the agent from hallucinating arbitrary CSS or mock UI components:
  176. - **`shadcn-ui` (`@jpisnice/shadcn-ui-mcp-server`)**: Standard accessible UI components and blocks.
  177. ```json
  178. "shadcn-ui": {
  179. "command": "npx",
  180. "args": ["-y", "@jpisnice/shadcn-ui-mcp-server"]
  181. }
  182. ```
  183. - **`neobrutalism` (`neobrutalism-mcp-server`)**: Neo-brutalist components, high-contrast borders, and pop palettes.
  184. ```json
  185. "neobrutalism": {
  186. "command": "npx",
  187. "args": ["-y", "neobrutalism-mcp-server"]
  188. }
  189. ```
  190. - **`magicui` (`@magicuidesign/mcp`)**: Interactive micro-interactions, landing page effects, and animations.
  191. ```json
  192. "magicui": {
  193. "command": "npx",
  194. "args": ["-y", "@magicuidesign/mcp"]
  195. }
  196. ```
  197. - **`ui-registry` (`ui-registry-mcp`)**: Catalog of 12+ modern design registries (Aceternity, Cult UI, SmoothUI, Kokonut).
  198. ```json
  199. "ui-registry": {
  200. "command": "npx",
  201. "args": ["-y", "ui-registry-mcp"]
  202. }
  203. ```
  204. - **`tailwindcss` (`tailwindcss-mcp`)**: Validates Tailwind CSS utility classes and theme configuration tokens.
  205. ```json
  206. "tailwindcss": {
  207. "command": "npx",
  208. "args": ["-y", "tailwindcss-mcp"]
  209. }
  210. ```
  211. #### 3. Browser Automation & Visual Testing MCPs
  212. - **`playwright` (`@playwright/mcp@latest`)**: Automated headless browser testing and visual screenshot validation.
  213. ```json
  214. "playwright": {
  215. "command": "npx",
  216. "args": ["-y", "@playwright/mcp@latest"]
  217. }
  218. ```
  219. - **`puppeteer` (`@modelcontextprotocol/server-puppeteer`)**: Headless browser automation and pixel-perfect PDF document rendering.
  220. ```json
  221. "puppeteer": {
  222. "command": "npx",
  223. "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
  224. }
  225. ```
  226. ---
  227. ### 4.5 Agent Configuration Mapping
  228. When installed, each agent consumes the skill via its native configuration architecture:
  229. | Target Agent | Installation Location | Integration Mechanism |
  230. | :--- | :--- | :--- |
  231. | **Google Antigravity (AGY)** | `~/.gemini/skills/architect-skill` & `~/.agy/skills/` | Loaded as native agent skill & callable via prompt/commands |
  232. | **Claude Desktop / Code** | `~/.claude/skills/architect-skill/SKILL.md` | Declarative markdown skill injected into agent context |
  233. | **Cursor IDE** | `~/.cursor/rules/architect-skill.mdc` | Semantic context rule with glob pattern indexing |
  234. | **Continue.dev** | `~/.continue/prompts/architect-skill.prompt` | Custom architecture design prompt template |
  235. | **Windsurf** | `~/.codeium/windsurf/.windsurfrules` or workspace `.windsurfrules` | System-level architectural directives |
  236. | **Cline** | Workspace `.clinerules` | Autonomous agent behavioral constraints |
  237. | **OpenAI Codex** | `~/.codex/skills/architect-skill` | Skill package for multi-turn architectural codegen |
  238. ### 4.4 Automated Backup & Rollback Protection
  239. Prior to modifying or overwriting any agent configuration, the installer automatically creates a timestamped snapshot in:
  240. ```
  241. ~/.architect-skill-backup/<timestamp>/<agent_name>/
  242. ```
  243. To inspect or revert, simply restore files from the respective timestamp folder or execute `node scripts/install.js --uninstall`.
  244. ### 4.5 Execution Protocol (How to Run)
  245. 1. **Interactive Design Wizard**: Ask the agent:
  246. > *"Activate architect-skill to design a new system: [System Name/Domain]"*
  247. 2. **Deterministic Stages**: Follow the Tier 1/2 elicitation process (Requirements $\to$ Architecture Style $\to$ Frontend Aesthetics $\to$ System Design).
  248. 3. **Artifact Generation**: Review outputs automatically generated into `./docs/` (`docs/requirements/`, `docs/architecture/`, `docs/diagrams/`).
  249. 4. **Verification**: Run `npm test` and `npm run validate:mermaid` to ensure zero hallucinations and valid UML diagrams.
  250. For extensive guides and documentation, explore the [`docs/`](docs/) directory:
  251. - [Workflow Guide](docs/workflow.md)
  252. - [Quickstart & Configuration Details](docs/quickstart.md)
  253. - [Wizard Execution Guide](docs/wizard-guide.md)
  254. - [Multi-Agent Adapters Reference](adapters/README.md)
  255. - [Documentation Index & Specifications](docs/spec/README.id.md)
  256. - [Community & Security Policies](docs/community/CONTRIBUTING.md)
  257. ---
  258. ## 5. Architectural Knowledge Base & Standards
  259. ### 5.1 Formal Requirements Engineering
  260. - **PRD (Product Requirements Document)**: Follows Atlassian agile framework with problem framing, user personas, Gherkin acceptance criteria, and MoSCoW prioritization.
  261. - **BRD (Business Requirements Document)**: Follows BABOK Guide v3 with strategic alignment, stakeholder RACI matrices, TCO/ROI financial calculations, and compliance constraints.
  262. - **SRD (System Requirements Document)**: Follows ISO/IEC/IEEE 29148:2018 (superseding IEEE 830) enforcing EARS syntax (Ubiquitous, Event-driven, State-driven, Unwanted, Optional) and IV&V verification matrices.
  263. ### 5.2 Architectural Paradigms
  264. - **Clean Architecture**: 4 concentric onion layers with the strict Dependency Inversion Rule and boundary DTOs.
  265. - **Modular Monolith**: Bounded contexts within a single deployment unit, public interface facades, and logical schema isolation.
  266. - **Event-Driven Architecture (EDA)**: Domain events, Event-Carried State Transfer (ECST), Transactional Outbox pattern, and Saga orchestration.
  267. - **Hexagonal Architecture**: Ports and Adapters decoupling application core from driving and driven infrastructure.
  268. - **Feature-Sliced Design (FSD v2.1)**: Strict hierarchical layer model (`app`, `pages`, `widgets`, `features`, `entities`, `shared`) for large-scale frontend and full-stack systems.
  269. ### 5.3 Distributed System Design Rigor
  270. - **Redis Caching**: Cache-Aside, Write-Through, Write-Behind, TTL jitter, and XFetch probabilistic early expiration algorithm to prevent cache stampedes.
  271. - **Distributed Locking**: Kleppmann monotonically increasing fencing tokens checked at the database layer to prevent split-brain writes under GC pauses.
  272. - **RDBMS Scaling**: Read/Write splitting with replica lag mitigation, PgBouncer/HikariCP connection pool sizing, and horizontal sharding.
  273. - **Async Message Queues**: Kafka, RabbitMQ, and AWS SQS patterns with Dead Letter Queues (DLQ) and exponential backoff jitter.
  274. - **Distributed Rate Limiting**: Sliding Window Counter and Token Bucket algorithms implemented via Redis Lua scripts.
  275. ### 5.4 Senior Frontend Aesthetics & UI Frameworks
  276. Integrates 6 official UI component libraries (Tailwind + shadcn/ui, DaisyUI, Mantine, Chakra UI, Ant Design, MUI) and 8 curated senior design aesthetic themes:
  277. 1. **Neubrutalism / Neo-Brutalism**: Hard 3px black borders, unblurred solid drop-shadows (`box-shadow: 4px 4px 0px #000`), vibrant saturated accents.
  278. 2. **Bento Grid / Linear-style**: Modular dark canvas (`#09090B`), subtle translucent borders, glowing ambient spotlight gradients.
  279. 3. **Glassmorphism & Aurora Gradient**: Multi-layer frosted glass backdrop blurs (`backdrop-blur-xl`), vibrant celestial violet/cyan lighting.
  280. 4. **Swiss / International Typographic Style**: Stark architectural grid, bold grotesque typography, zero ornamentation, red/black accents.
  281. 5. **Modern SaaS Clean Enterprise**: Balanced slate neutrals, crisp 1px borders, subtle elevation, accessible status badges.
  282. 6. **Material Design 3**: Dynamic tonal palettes, surface tint elevations, pill-shaped action triggers.
  283. 7. **Neumorphism / Soft UI**: Opposing directional soft shadows on continuous neutral surfaces (with mandatory high-contrast text reinforcements).
  284. 8. **Retro / Cyberpunk / Terminal**: Monospaced typography, CRT scanlines, neon phosphor green/amber accents on pitch-black surfaces.
  285. ---
  286. ## 6. Generated Output Hierarchy (`./docs/`)
  287. When executed, `architect-skill` compiles your technical documentation into `./docs/`:
  288. ```
  289. ./docs/
  290. ├── README.md # Main navigation portal and documentation index
  291. ├── .architect-manifest.json # Machine-readable metadata, option choices, and SHA-256 hashes
  292. ├── .architect-audit.log # Local append-only event log (zero credential leakage)
  293. ├── .gitignore # Output-level exclusion of secrets, keys, and temporary state
  294. │
  295. ├── requirements/
  296. │ ├── PRD.md # Product Requirements Document (Atlassian)
  297. │ ├── BRD.md # Business Requirements Document (BABOK - Tier 2)
  298. │ ├── SRD.md # System Requirements Document (ISO/IEC/IEEE 29148 - Tier 2)
  299. │ └── [custom].md # Sanitized custom requirements or RFCs
  300. │
  301. ├── architecture/
  302. │ ├── decisions/
  303. │ │ ├── ADR-001-*.md # Architecture Decision Records
  304. │ │ └── ADR-002-*.md
  305. │ └── [selected-architecture]/
  306. │ ├── layer-rules.md # Boundary rules and import constraints
  307. │ ├── directory-tree.md # Concrete project codebase tree
  308. │ └── dependency-injection.md # Service lifetimes and DI registration (Tier 2)
  309. │
  310. ├── system-design/
  311. │ └── [selected-design]/
  312. │ ├── caching-lifecycle.md # Redis caching patterns and TTL policies
  313. │ ├── concurrency-locking.md # Distributed locking with fencing tokens
  314. │ └── rdbms-scaling.md # Read replicas, partitioning, and connection pools
  315. │
  316. ├── diagrams/
  317. │ ├── architecture/
  318. │ │ └── c4-container.mmd # C4 model container diagram
  319. │ ├── data/
  320. │ │ └── erd.mmd # Relational Entity Relationship Diagram
  321. │ ├── sequence/
  322. │ │ └── sequence-auth-flow.mmd # Protocol and transaction sequence diagrams
  323. │ └── state/
  324. │ └── state-lifecycle.mmd # Finite state machine model
  325. │
  326. └── ui/
  327. └── [selected-ui-framework]/
  328. ├── setup-guide.md # Build configuration and dependencies
  329. ├── theme-tokens.md # CSS custom properties and design tokens
  330. └── component-registry.md # UI component specifications and ARIA accessibility
  331. ```
  332. ---
  333. ## 7. Verification Utilities & Diagnostics
  334. The toolkit provides automated zero-dependency verification scripts:
  335. ```bash
  336. # Verify environment health, permissions, and script integrity
  337. node scripts/doctor.js
  338. # Validate Mermaid UML diagram syntax across assets and generated output
  339. node scripts/validate-mermaid.js
  340. # Validate preview-safe text diagrams (ASCII .md twins that render in VSCode preview without Mermaid)
  341. node scripts/validate-diagrams.js
  342. # Validate repository structure against the blueprint
  343. node scripts/validate-structure.js
  344. # Validate cross-document semantic consistency (PRD <-> SRD <-> ERD <-> ADR)
  345. node scripts/validate-output.js
  346. # Execute secret scanner to detect and mask credential patterns
  347. node scripts/secret-scan.js --check
  348. ```
  349. ---
  350. ## 8. Security & Governance
  351. - **Zero-Egress Enforcement**: Monitored by `scripts/egress-guard.js`. Any unauthorized outbound network socket throws an immediate fatal error.
  352. - **Credential Protection**: Monitored by `scripts/secret-scan.js` and `policies/redaction-rules.json`.
  353. - **Filesystem Isolation**: Monitored by `policies/filesystem-scope.json`.
  354. - **Integrity Pinning**: Monitored by `runtime-firewall/tool-firewall.js`.
  355. For security vulnerability disclosure, review [`SECURITY.md`](SECURITY.md).
  356. For local data sovereignty details, review [`PRIVACY.md`](PRIVACY.md).
  357. ---
  358. ## 9. License
  359. This project is licensed under the [MIT License](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.