The Technique: Domain Expert as Orchestrator
The Cara Platform team didn't just ask Claude Code to "build an architecture." Technical co-founder Widal designed the architecture, planned all 66 tickets, and directed the agent with specific clinical compliance requirements. This eliminated the translation layer between domain knowledge and technical execution.
Key insight: The bottleneck wasn't headcount—it was having expertise close enough to the problem to make the right calls. With 15+ years in tech and 7 in healthtech, Widal provided the domain context Claude Code needed to make correct architectural decisions autonomously.
Why It Worked: The Execution Harness
This wasn't about AI magic. It was about the execution harness—the system surrounding the model that turned raw capability into reliable output. The setup included:
- Clear ticket definitions: Each of the 66 tickets had specific requirements and acceptance criteria
- Autonomous execution: Claude Code (Opus 4.6) worked across 2 repositories without constant human intervention
- Safety architecture: Two full security audits found and fixed 10 issues immediately, with zero deferred
- Testing rigor: 536 tests written alongside the 20k lines of code
The agent shipped a composable 5-layer architecture for their healthcare app platform, transforming 25 flat scaffolds into a system where combinations like "behavioral health app with voice AI on Athena" could snap together automatically.
How To Apply This To Your Workflow
1. Start with Domain Expertise in the Loop
Don't expect Claude Code to understand your business logic without context. Before starting a session:
# Create a context file with domain-specific requirements
claude code --context ./architecture-requirements.md --model opus-4.6
Your architecture-requirements.md should include:
- Business constraints (HIPAA compliance, clinical workflows)
- Technical boundaries (AWS SDK restrictions, third-party API limitations)
- Success criteria for each component
2. Break Work into Atomic Tickets
The 66 tickets weren't monolithic. Each represented a discrete architectural component. Structure your work similarly:
## Ticket Structure Example
- **Ticket:** Implement authentication scaffold for EHR systems
- **Scope:** TypeScript module with typed interfaces for Athena, Epic, Cerner
- **Dependencies:** Platform managed services only (no direct AWS SDK calls)
- **Tests:** Unit tests for each EHR adapter + integration tests
- **Acceptance:** Passes security audit, handles token refresh, logs appropriately
3. Use Claude Code's Multi-Repository Capabilities
The agent worked across 2 repositories simultaneously. When you need cross-repo coordination:
# Initialize session with multiple codebases
claude code --repo ./platform-core --repo ./scaffold-library --model opus-4.6
4. Implement Safety Gates
Two security audits caught critical bugs. Build similar checks into your workflow:
# Run security audit after major changes
claude code "Run security scan on changed files and report critical issues"
# Or integrate with your existing CI/CD
claude code "Generate security test cases for the new authentication layer"
5. Trust but Verify
While the agent ran autonomously for 4 hours, the human expert:
- Designed the architecture upfront
- Planned all tickets
- Reviewed security audit results
- Maintained execution authority
Your role: Be the architect and director, not the micromanager. Give Claude Code clear specifications, then let it execute while you monitor progress and handle exceptions.
The Results Speak for Themselves
- 66 tickets executed autonomously
- 536 tests written
- ~20,000 lines of code
- 2 security audits completed
- 10 issues found and fixed immediately
- Zero deferred bugs
- 4 hours total execution time
All while the technical founder watched "a gloriously weird 80s movie" with his partner.
What This Means for Your Development Process
This case study demonstrates that Claude Code isn't just for small refactors or boilerplate code. With proper orchestration, it can handle complex, multi-component architecture work at scale. The key is treating Claude Code as a highly capable execution engine that needs clear direction from domain experts.
Start small: break your next architectural change into discrete tickets, provide clear context, and let Claude Code handle the implementation while you focus on design and review. You might be surprised how much can get done while you're watching a movie.
