architecture-cowork-plugin

# Architect — Cowork Plugin

Turn product ideas into structured, buildable architecture blueprints. Generate SDL specifications, C4 diagrams, cost estimates, complexity scores, AI coding rules, and scaffold complete projects.

Built for founders. Useful for engineers.

## Installation

### Claude Code

```
/plugin marketplace add navraj007in/architecture-cowork-plugin
/plugin install architect@architect
```

### Cowork (Claude Desktop)

1. Open Claude Desktop → Cowork tab
2. Click "Plugins" in the left sidebar
3. Click "Upload plugin" and select the plugin folder

### Manual install from GitHub

```bash
git clone https://github.com/navraj007in/architecture-cowork-plugin.git
```

Then add the plugin directory in Claude Code's plugin settings or upload it in Cowork.

## Commands

| Command                            | Description                                                                       |
| ---------------------------------- | --------------------------------------------------------------------------------- |
| `/architect:blueprint`             | Full architecture blueprint — diagrams, costs, complexity, specs, and next steps  |
| `/architect:quick-spec`            | 5-minute lightweight architecture overview for idea validation                    |
| `/architect:import`                | Import an existing codebase — analyze structure, detect stack, generate SDL        |
| `/architect:sdl`                   | Generate, validate, diff, or browse SDL architecture specifications               |
| `/architect:scaffold`              | Create project structure plan from a blueprint architecture                        |
| `/architect:scaffold-component`    | Scaffold a single component from the SDL with full starter code                    |
| `/architect:implement`             | Implement a user story or feature end-to-end into an already-scaffolded codebase   |
| `/architect:review`                | Review code changes against the project's own patterns, best practices, and security |
| `/architect:cost-estimate`         | Infrastructure + third-party + LLM token cost breakdown                           |
| `/architect:complexity-check`      | Build difficulty assessment with 10-factor scoring                                |
| `/architect:agent-spec`            | AI agent architecture — orchestration, tools, guardrails, token costs             |
| `/architect:compare-stack`         | Side-by-side technology comparison with recommendation                            |
| `/architect:hiring-brief`          | Developer hiring package with role descriptions and interview questions           |
| `/architect:well-architected`      | Six-pillar well-architected review with scores and improvement roadmap            |
| `/architect:design-system`         | Design system generation — 11 personalities, diverse font pairs, dark mode, unconventional layouts, consumer/creative domains |
| `/architect:generate-data-model`   | Generate ORM schemas (Prisma, SQLAlchemy, Mongoose, Drizzle) from blueprint types |
| `/architect:setup-env`             | Walk through account setup, validate API keys, write verified .env files          |
| `/architect:setup-cicd`            | Configure real CI/CD pipelines in GitHub Actions, Azure Pipelines, or GitLab CI   |
| `/architect:security-scan`         | Validate scaffolded code against the blueprint's security checklist               |
| `/architect:sync-backlog`          | Push sprint backlog into Azure DevOps or Jira as sprints and work items           |
| `/architect:publish-api-docs`      | Generate interactive API documentation (Swagger UI, Redoc, AsyncAPI)              |
| `/architect:export-diagrams`       | Render Mermaid diagrams to PNG/SVG with light and dark themes                     |
| `/architect:deep-research`         | Web-verified competitor analysis, market sizing, and differentiation map          |
| `/architect:launch-checklist`      | Pre-launch readiness checklist — infra, security, legal, analytics, go-live      |
| `/architect:onboarding-pack`       | Developer onboarding package for first hire or agency handoff                     |
| `/architect:investor-update`       | Stakeholder progress update pre-filled from CRs, ADRs, costs, and scaffold data  |

## What You Get

### From `/architect:blueprint` (flagship command)

A complete architecture blueprint with 15 deliverables:

1. **Executive Summary** — one-page overview with cost breakdown, complexity score, and architecture pattern
2. **Architecture Diagram** — C4 Container diagram in Mermaid, plus agent flow diagram if applicable
3. **Application Architecture & Patterns** — architecture pattern (clean, hexagonal, modular monolith, etc.), folder structure, design principles
4. **Shared Types & Cross-Service Contracts** — shared domain types, service contracts (OpenAPI, event schemas, Protobuf)
5. **API Artifacts** — OpenAPI/Swagger specs, Postman collections, AsyncAPI specs, GraphQL schemas
6. **Security Architecture** — auth strategy, API security checklist, data protection, OWASP threat mitigations
7. **Observability & Monitoring** — structured logging, health checks, metrics, alert thresholds, distributed tracing
8. **DevOps Blueprint** — CI/CD pipeline, branch strategy, environment definitions, config management
9. **Cost Estimate** — infrastructure + third-party + LLM token costs in low/medium/high scenarios
10. **Complexity Assessment** — 10-factor scoring with risk flags and simpler alternatives
11. **Well-Architected Review** — 6-pillar evaluation with per-pillar scores and improvement roadmap
12. **Plain English Specifications** — features written for non-technical stakeholders
13. **Required Accounts** — every third-party service with signup URL, setup steps, and free tier details
14. **Next Steps Guide** — 3 paths forward: build with AI tools, hire a developer, or hire an agency
15. **Sprint Backlog** — time-boxed sprint plan with goals, user stories, and dependencies

### From `/architect:import`

Analyze an existing codebase and generate an SDL specification from it. Detects runtime, framework, database, auth strategy, API patterns, and project structure. Produces a multi-file SDL that captures the existing architecture.

### From `/architect:scaffold-component`

Scaffold a single component from the SDL with:
- Framework-appropriate starter code
- Package manifest with `dev` and `start` scripts
- Dockerfile and docker-compose.yml
- .env.example with all required variables
- CI workflow
- AI coding rules (CLAUDE.md, .cursorrules, copilot-instructions.md)
- Scaffold manifest for progress tracking

Files are created at the exact path specified in the SDL's `path` field for the component.

### From `/architect:design-system`

Generate a complete design system from the SDL's design section:
- Design tokens (colors, typography, spacing, shadows)
- Component library setup (Tailwind, Chakra, MUI, etc.)
- Palette generation with accessibility compliance
- Typography scale with font family selection
- Domain-appropriate color recommendations

### From `/architect:deep-research`

Web-verified market intelligence using Claude's WebSearch and WebFetch tools:
- **Competitor landscape** — 5-8 direct competitors with verified pricing, funding, features, and weaknesses
- **Market sizing** — TAM/SAM/SOM with sourced estimates and confidence tags ([Verified]/[Estimated])
- **Feature comparison matrix** — your product vs competitors across key dimensions
- **Opportunity gaps** — underserved market segments and missing features
- **Technology trends** — relevant industry and adoption trends
- All claims sourced with URLs and data freshness dates

### From `/architect:launch-checklist`

Pre-launch readiness checklist tailored to your SDL and deployment config:
- Infrastructure (DNS, SSL, CDN, auto-scaling)
- Monitoring (error tracking, APM, alerts, health checks)
- Security (secrets rotation, CORS, rate limiting, OWASP)
- Data (backups, migrations, retent

[truncated…]