Session Discipline
Every AI session is tracked, audited, and summarized. No more losing context between sessions or wondering what happened yesterday.
- Pre-session audits surface blockers and context from prior work
- Session checkpoints detect scope drift before it compounds
- Work summaries capture what was done, what's next, and what's blocked
- Session recaps on startup so you never start cold
Code Quality
DevArch doesn't just track work — it enforces engineering standards through every edit.
- Mutation verification ensures side-effect functions actually persist state and tests assert on changes
- Modular architecture: separation of concerns, clear module boundaries, no god objects
- Solid test coverage: tests that verify behavior, not just existence
- Clean coding: small focused functions, clear naming, no dead code, no over-engineering
Commit Discipline
Structured, traceable commits with mandatory session context.
- Conventional commit format with meaningful messages
- Work summaries staged with every commit
- Session file cleanup and archival on commit
- Hooks prevent committing without documentation
Planning Gates
Non-trivial work gets planned before implementation begins. No more "fix the login" turning into a full auth rewrite.
- Session planner decomposes goals into phased work
- Plan-review gate blocks implementation until you approve the plan
- Budget tracking keeps sessions focused
- Pattern recurrence detection flags systemic issues
DDD Assessment
Not sure if your project needs DDD? Run an assessment before committing to a tier.
- Scans your codebase for domain complexity signals
- Identifies bounded context candidates from module structure
- Detects tactical patterns already present in your code
- Recommends the right tier with reasoning
Conversational Domain Discovery
Describe your business domain in natural language. DevArch listens and captures structured domain knowledge automatically.
- Talk about your domain — the notation-generator agent captures terms, actors, scenarios, and contexts
- Ubiquitous language emerges from conversation, not upfront design sessions
- "Show me the model" renders your domain as a readable summary, not a YAML dump
Light Notation
Ten discovery elements that capture the shape of your domain without implementation details.
- Terms — the ubiquitous language of your domain
- Actors — roles that initiate action
- Scenarios — step-by-step business workflows with validation chains
- Concepts — nouns from scenarios before they're classified
- Bounded contexts — language and ownership boundaries
- Events, commands, invariants, variants, policies
Domain-Aware Planning
Session planning becomes domain-aware. The planner understands bounded context boundaries and suggests work that respects them.
- Vocabulary enforcement: code suggestions use domain terms over generic programming terms
- Gap reporting: "what's incomplete?" shows what your domain model is missing
- Domain knowledge persists across sessions via notation files
Source Materials Registry
Catalog photos, transcripts, whiteboard shots, and recordings from domain discovery sessions. Link them to your notation for full traceability.
/register-source — catalog raw materials with type, date, participants, and context metadata/extract-from-source — pull domain terms, events, commands, and scenarios from source files using Claude's multimodal capabilities/list-sources — query sources by type, context, date range, or extraction status- External storage with local mount points — large files stay on shared drives, not in your repo
- Bidirectional linking between source entries and notation elements
Complete Notation
All 24 element types spanning discovery, technical modeling, and implementation.
- Aggregates, entities, and value objects with ownership boundaries
- Property stickiness analysis — how the same concept differs across contexts
- Context relationships: customer-supplier, ACL, conformist, shared kernel, and more
- Integration mechanisms: how bounded contexts communicate at runtime
- Command handlers, event handlers, repositories, and test mappings
Code Scaffolding
Generate implementation code directly from your domain model. The model constrains the code, not the other way around.
- Aggregate roots, command handlers, event classes, repository interfaces
- Code structure aligned with your notation and project conventions
- Language and framework aware — respects your existing stack
Domain/Code Synchronization
Keep your domain model and codebase aligned as both evolve.
- Warns when concepts exist in code but not notation — or vice versa
- Suggests notation updates when new domain concepts emerge in conversation
- Cross-context maps visualize integration boundaries
Source Traceability
Full DDD extends Source Materials with automatic notation linking during generation.
- Notation generator auto-populates
source_ref fields when elements originate from registered sources
- Cross-reference queries: trace any domain element back to the discovery session that produced it
Progressive Validation
As your domain model matures, validation tightens automatically.
- Triggers at 3+ bounded contexts or 5+ aggregates
- Flags duplicate concept names across bounded contexts
- Warns about aggregates with no commands or events
- Suggests missing anti-corruption layers at context boundaries