Claude Code can autonomously execute complex architecture work when given proper domain expertise, ticket planning, and execution authority—no magic required.

How a Healthcare Startup Used Claude Code to Ship 66 Architecture Tickets in 4 Hours

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.

---

Originally published on gentic.news