This article was originally published on Saru Blog.
What You'll Learn
- The reality of large-scale development with Claude Code
- What to delegate to AI vs. what requires human judgment
- Actual workflow with a 200K-line codebase
The Project in Numbers
| Metric | Value |
|---|---|
| Lines of code | ~200K (Go 84K + TypeScript 113K) |
| Development period | ~3 months (Oct 2025–) |
| Commits | 311 |
| Developers | 1 |
| Portals | 4 (System / Provider / Reseller / Consumer) |
| APIs | 4 (dedicated to each portal) |
One person. Three months. 200K lines.
To be honest, Claude Code wrote most of this code. My job is to set direction, review, and make decisions.
What is Claude Code?
A CLI-based AI coding agent from Anthropic. Unlike ChatGPT or Copilot:
- Autonomous: Say "implement this feature" and it reads files, writes code, runs tests
- Wide context: Understands 200K tokens (~150K lines) at once
- CLI-native: No VS Code dependency, works entirely in terminal
Actual Workflow
A Typical Day
Morning: Pick one Issue
↓
Claude Code: "Implement this feature"
↓
Claude Code: Generates spec.md
↓
Me: Review, request changes
↓
Claude Code: Generates plan.md
↓
Me: Review, approve
↓
Claude Code: Implementation
↓
Me: Verify behavior, code review
↓
Claude Code: Create tests
↓
Me: Merge
My actual work time: 2-3 hours per day. The rest of the time, Claude Code is working while I do other things.
Concrete Example: Order Creation Feature
A recent implementation: "Order Creation UI"
My input (one line):
Add the ability to create Orders directly from the UI, without going through Cart/Quote.
Claude Code's output:
- Specification (use cases, functional requirements, non-functional requirements)
- API design (6 endpoints)
- Frontend design (2 portals × 3 pages)
- Implementation code (Go + TypeScript)
- E2E tests
- Internationalization (Japanese/English)
Time: ~4 hours (of which ~1 hour was my work)
What I Delegate to AI
1. Structuring Specifications
Transforming vague requirements into structured specifications.
Before (my input):
I want Providers to be able to create Orders directly for their Consumers
After (Claude Code's output):
## Use Cases
| Scenario | Actor | Portal | Description |
|----------|-------|--------|-------------|
| S2P | Provider | Provider Portal | Internal Order creation |
| P2C | Provider | Provider Portal | Order for Consumer |
| C2C | Consumer | Consumer Portal | Self-service purchase |
## Functional Requirements
- FR-1.1: Provider can create new Order from /orders/new
- FR-1.2: Customer selection (self or from Consumer list)
...
It organizes the vague ideas in my head into comprehensive specifications.
2. Following Existing Patterns
Reading 200K lines and generating code that matches existing patterns.
For example:
- API endpoint naming conventions
- Error handling patterns
- Frontend directory structure
- Test writing style
This is the most valuable part. New code stays consistent with existing code. When humans write, personal habits creep in and break codebase uniformity.
3. Repetitive Tasks
With 4 portals × 4 APIs, I often write similar code four times.
Example: Adding a new entity requires:
- Handler (4 APIs)
- Router config (4 APIs)
- Frontend pages (4 portals)
- Type definitions (shared package)
- E2E tests (4 portals)
Doing this manually takes half a day. Claude Code does it in 30 minutes.
4. Test Creation
Deriving test cases from implementation code. Comprehensively covering edge cases.
// Test cases generated by Claude Code
test('should show error when quantity is 0', ...)
test('should show error when quantity is negative', ...)
test('should show error when quantity exceeds stock', ...)
test('should disable submit button while loading', ...)
test('should redirect to list page after successful creation', ...)
Writing tests is tedious work. Good decision to delegate to AI.
What Requires Human Judgment
1. What to Build
I don't let AI decide "what to implement next." Business priorities, technical debt, user feedback—synthesizing these is human work.
2. Trade-off Decisions
AI presents options, but final decisions are human.
Example: Choosing authentication method
Claude Code: "JWT or session-based?"
Me: "JWT. Because..."
AI can't decide "which is correct." Judgment considering context (team size, operations, future extensibility) can only be made by humans.
3. Final Security Review
RLS (Row-Level Security) policies, authentication/authorization logic—humans always review these.
AI can write "working code," but whether it's "secure code" is a different matter.
4. Deciding "Don't Do It"
AI tries to do what it's asked. "This feature isn't needed" or "this implementation is overkill" are human judgments.
In practice, I reject about 30% of features Claude Code proposes as "not needed now."
Impact on Productivity
Quantitative Changes
| Metric | Before (pre-AI experience) | After (Claude Code) |
|---|---|---|
| Time per feature | 2-3 days | 4-6 hours |
| Daily commits | 2-3 | 5-10 |
| Test coverage | Depends on motivation | Always 80%+ |
Feels 3-5x faster.
Qualitative Changes
- Less tedious work: Boilerplate, tests, documentation
- More time for design: Delegate implementation to AI, spend more time on architecture
- Maintained consistency: Code style unified across 200K lines
Caveats and Limitations
1. Review is Mandatory
Never merge Claude Code's output directly. Always read it.
In practice, about 1 in 10 times there's something "not quite right." Trust the AI, but don't skip verification.
2. Context Limitations
200K tokens is wide, but can't understand the entire 200K-line codebase at once.
Workarounds: explicitly specify related files, split sessions.
3. Weak on Latest Information
Claude Code's knowledge is frozen at training time. Latest library updates and best practices need human supplementation.
4. It Costs Money
Claude Code isn't free. Tens to hundreds of dollars per month. But considering the productivity gains, it more than pays for itself.
Solo Development × AI Possibilities
Three months ago, saying "I'll build 4 portals × 4 APIs alone" would have seemed insane.
Not anymore. With an AI agent, one person can build enterprise-scale systems.
However, AI is "10 pairs of hands," not "10 brains."
- Direction is set by humans
- Decisions are made by humans
- Responsibility is taken by humans
AI is like an excellent junior engineer. It does whatever you ask, but you need to figure out what to ask.
Summary
| Point | Detail |
|---|---|
| Scale | 200K lines, 4 portals × 4 APIs |
| Period | 3 months, 311 commits |
| AI's role | Structuring specs, following patterns, repetitive tasks, tests |
| Human's role | Priority decisions, trade-offs, security review, "don't do it" calls |
| Productivity | Feels 3-5x faster |
Even solo, partnering with AI, you can build big things.
Series Articles
- Part 1: Tackling Unmaintainable Complexity with Automation
- Part 2: WebAuthn Testing in CI with Virtual Authenticators
- Part 3: Next.js × Go Monorepo Architecture
- Part 4: Multi-Tenant Isolation with PostgreSQL RLS
- Part 5: Multi-Portal Authentication Pitfalls with Keycloak
- Part 6: Building a 200K-Line SaaS Solo with Claude Code (this article)
Top comments (0)