The Brain: Git-Based Documentation as Development Accelerator

At DormWay, our documentation system — “the Brain” — is a git-managed, markdown-based knowledge repository compiled with mkdocs. It sits alongside all our other repositories in a workspace where Claude Code operates, creating a development environment where context and implementation live in the same directory structure.

Technical Architecture

The documentation lives in a dedicated git repository with 388 documents structured as:

docs/
├── product/
├── technical/
├── research/
├── marketing/
└── operations/

Claude Code runs in a parent directory containing:

• The Documentation repository
• DormWay iOS app repository
• API Gateway
• Engine (Temporal based)
• AI System
• Config scripts and micro services (document uploader, relays, message brokers, etc)

Agent Steering with CLAUDE.md Files

Throughout our codebase, we maintain CLAUDE.md files that serve as contextual steering documents for AI agents, containing:

• Repository-specific coding standards and patterns
• Architecture decisions and constraints
• Common tasks and preferred implementation approaches
• Links to relevant documentation sections

Multi-Agent Workflow Integration

We integrate multiple AI tools into our development workflow:

• Claude Code for implementation (it's still the best)
• OpenAI GPT-4 for specialized analysis
• Claude Desktop for interactive problem-solving, ideation and system design
• Read.AI for processing meeting transcripts and user interviews

All outputs flow into the git-managed workspace where Claude Code can reference them alongside code and documentation.

Real-World Example: Schedule Ingestion for Onboarding

Here’s how the system works in practice. We needed to build schedule ingestion for student onboarding:

1. Ideation Call: Riley and I discussed various approaches for parsing student schedules - OCR for syllabus PDFs, Canvas API integration, manual input with smart parsing.
2. AI Processing: Read.AI processed the call transcript and generated a summary document that got committed to our docs repository, capturing the key requirements and constraints. We use their webhook integration to do this.
3. Technical Design: Claude Code then analyzed the transcript summary, examined our existing TypeScript API patterns for data ingestion, reviewed our SwiftUI onboarding flow components, and consulted the relevant CLAUDE.md files. It produced a complete technical specification including:

• API endpoint design for schedule parsing
• Database schema changes for storing parsed schedule data
• SwiftUI component modifications for the onboarding flow
• Integration points with our existing Temporal workflows

1. Implementation Reference: When we implemented the feature, we used that AI-generated technical spec as the foundation, which already accounted for our existing code patterns and architectural constraints.

This eliminated the typical cycle of design-implement-refactor that happens when requirements don’t account for existing technical constraints.

Live Documentation Updates

Documentation lives in git alongside code, maintained using the same pull request workflow. Claude Code drafts documentation updates as part of feature development, guided by CLAUDE.md files that specify documentation standards.

Cross-Repository Context

Claude Code maintains contextual awareness across repositories:

• References user research findings when implementing UI components
• Cross-checks API changes against client requirements
• Validates features align with documented product requirements
• Follows repository-specific patterns defined in CLAUDE.md files
• Incorporates insights from Read.AI summaries and OpenAI analysis

Future: Scaling with MCP and Automated Interaction

We’re implementing the Claude Code Model Context Protocol (MCP) to standardize agent interactions and exploring N8N-based chatbot interfaces for team queries without directly invoking Claude Code.

This automation layer will enable:

• Slack-based queries: “What’s our current approach to Canvas authentication?”
• Automated status updates and daily summaries
• Self-service onboarding for new team members

The goal is decoupling human interaction from the brain agent as we scale.

Results

Riley and I work completely asynchronously and get significant work done efficiently. The system eliminates context switching and ensures architectural consistency across our 388 documentation files and multiple repositories. Features like schedule ingestion go from ideation to implementation without the typical design-code mismatch cycle.

Technical Considerations

CLAUDE.md files serve as the coordination mechanism, ensuring each agent understands its role within the larger system. The MCP implementation provides standardized protocols for agent communication, while N8N workflows enable accessible human-agent interaction patterns.

This architectural evolution prepares us for rapid team scaling without losing the contextual benefits of our integrated documentation system.