Help us improve
Share bugs, ideas, or general feedback.
From attune
Researches architectural paradigms based on project context, recommends one from 14 options, initializes with customized templates, and creates an ADR.
npx claudepluginhub athola/claude-night-market --plugin attuneHow this command is triggered — by the user, by Claude, or both
Slash command
/attune:arch-initThe summary Claude sees in its command listing — used to decide when to auto-load this command
# Attune Architecture-Aware Init Command Research-driven project initialization that selects appropriate architectural paradigms based on project needs. ## When To Use Use this command when you need to: - Start a new project with architecture guidance - Choose between architectural paradigms (hexagonal, clean, etc.) - Get research-backed architecture recommendations - Initialize project with paradigm-specific templates - Understand trade-offs of different architectures ## When NOT To Use Avoid this command if: - Architecture already decided (use `/attune:project-init` directly) - Simpl...
/startBootstraps a new project from a free-form description: verifies working directory, guards against re-initializing existing projects, and spawns sub-agents for architecture, planning, development, QA, and security review.
/brainstormBrainstorms high-level architecture options collaboratively with diagrams and package research to create an implementation plan.
/decideRuns an architecture deep research pipeline: scans the repo for patterns, drafts a PRD, live-researches the decision space with citation audits, and produces a handoff-ready decision report.
/architecture-advisorGuides interactive architecture decisions: discovers requirements and constraints, analyzes codebase, proposes 2-3 options with trade-offs, documents ADR.
/dev-newExecutes architecture-first greenfield development: designs full system architecture before implementation based on project description, following phased paradigm with quality gates.
/startGuides ArcKit project onboarding via architecture-workflow skill, adapts to workflow focus (e.g., 'new project'), detects state, and recommends tailored command plan.
Share bugs, ideas, or general feedback.
Research-driven project initialization that selects appropriate architectural paradigms based on project needs.
Use this command when you need to:
Avoid this command if:
/attune:project-init directly)# Interactive mode (recommended) - guides through architecture selection
/attune:arch-init --name my-project
# Specify language and let it recommend architecture
/attune:arch-init --name my-project --lang python
# Specify both language and architecture
/attune:arch-init --name my-project --lang python --arch hexagonal
# Accept recommended architecture without prompting
/attune:arch-init --name my-project --lang python --accept-recommendation
Gathers project context:
Researches best practices:
Recommends architecture paradigm from 14 available options:
Customizes templates based on chosen paradigm
Creates Architecture Decision Record (ADR) documenting the choice
| Scenario | Command |
|---|---|
| Architecture already decided | /attune:project-init |
| Need architecture guidance | /attune:arch-init |
| Exploring multiple architectures | Use Skill(archetypes:architecture-paradigms) first |
| Quick setup with defaults | /attune:project-init |
# 1. Invoke skill to guide architecture-aware initialization
Skill(attune:architecture-aware-init)
# 2. The skill will:
# - Gather project context
# - Research best practices online
# - Recommend paradigm based on decision matrix
# - Customize templates for chosen paradigm
# - Create ADR
# 3. After architecture selected, initializes project
python3 plugins/attune/scripts/attune_arch_init.py \
--name my-project \
--lang python \
--arch hexagonal
--name <name> - Project name--lang <language> - Project language (python, rust, typescript)--arch <paradigm> - Architecture paradigm (e.g., hexagonal, functional-core, cqrs-es)--accept-recommendation - Accept recommended architecture without prompting--skip-research - Skip online research phase (use decision matrix only)The command uses a decision matrix based on team size and domain complexity:
| Team Size | Simple Domain | Moderate | Complex | Highly Complex |
|---|---|---|---|---|
| < 5 | Layered | Layered/Hexagonal | Hexagonal | Functional Core |
| 5-15 | Layered | Modular Monolith | Modular Monolith | Hexagonal + FC |
| 15-50 | Modular Monolith | Microservices | Microservices | CQRS/ES |
| 50+ | Microservices | Microservices | Event-Driven | Space-Based |
/attune:arch-init --name payment-service --lang python
Interactive flow:
Project type: Web API
Domain complexity: Highly Complex (fintech regulations)
Team size: 8 engineers
Requirements: Audit trails, security, compliance
Research results:
- CQRS/Event Sourcing recommended for audit requirements
- Hexagonal also suitable for clean separation
Recommended: CQRS + Event Sourcing
Rationale: Complete audit trail via event log, complex business rules...
Accept recommendation? [Y/n]: y
Creating project structure for CQRS/ES architecture...
/attune:arch-init --name my-cli --lang python --arch functional-core
Creates Functional Core, Imperative Shell structure:
my-cli/
├── src/
│ └── my_cli/
│ ├── core/ # Pure business logic
│ │ ├── domain.py
│ │ ├── operations.py
│ │ └── commands.py
│ └── adapters/ # Side effects
│ ├── cli.py
│ ├── filesystem.py
│ └── config.py
├── tests/
├── docs/
│ └── adr/
│ └── 001-functional-core-architecture.md
└── ...
After completion, you'll have:
/attune:project-init - Standard initialization (when architecture is decided)/attune:brainstorm - Explore project needs before architecture selection/attune:war-room - Multi-expert deliberation for complex decisionsSkill(attune:architecture-aware-init) - Full architecture-aware flowSkill(archetypes:architecture-paradigms) - Paradigm selection guideSkill(archetypes:architecture-paradigm-*) - Specific paradigm implementation