TL;DR
- Developer shipped a production macOS app with 95% of 20,000 lines generated by Claude Code
- Development time: weeks instead of months (5-10x velocity improvement)
- Passed App Store review on first submission with no rejections
- Best for: Well-documented domains where developer can evaluate AI output
- Key approach: Upfront architecture definition, then feature-by-feature AI implementation with human review
A developer shipped a production macOS app to the App Store with 95% of its 20,000 lines of Swift code generated by Claude Code — completing in weeks what would have taken months of manual development.
Indragie wanted to build a macOS app.
Context would be a productivity tool — helping users manage their windows and workspaces. Native Swift. Production quality. App Store ready.
The scope was significant: complex UI, system integrations, preference panels, keyboard shortcuts, accessibility features. Normally a multi-month project for an experienced iOS/macOS developer.
“I wondered what would happen if I let Claude Code do most of the work.”
The result: 20,000 lines of Swift. Ninety-five percent AI-generated. A shipping product.
The Starting Point
Indragie wasn’t new to development. He’d built macOS apps before. He knew Swift, SwiftUI, AppKit.
But this time, instead of writing code, he’d describe what he wanted.
“I gave Claude the architecture. The feature specs. The UI sketches. Then I let it implement.”
The role shift: from coder to director.
The Architecture Session
Before any implementation, Indragie spent time on architecture.
“I described the overall structure: how windows would be managed, what the data model looked like, how preferences would be stored, how the menu bar app would interact with the main functionality.”
Claude absorbed the architecture. Asked clarifying questions. Then started generating scaffolding.
“The first few hundred lines were structure: files, folders, protocols, basic types. The foundation Claude would build on.”
The Implementation Velocity
With architecture in place, implementation moved fast.
Window management logic: describe the behavior, receive the code.
UI components: describe the layout, receive SwiftUI views.
System integrations: describe the APIs needed, receive the implementation.
“Each feature was a conversation. I’d explain what it should do. Claude would implement. I’d test. We’d iterate.”
Twenty thousand lines accumulated through hundreds of these cycles.
The 95% Number
Indragie tracked what Claude generated versus what he wrote himself.
Claude generated:
- All SwiftUI views and layouts
- All data models and persistence
- All window management logic
- All keyboard shortcut handling
- All menu bar functionality
- Most accessibility implementations
Indragie wrote:
- Critical system-level integrations requiring precise control
- Bug fixes where Claude’s solution didn’t work
- Final polish and edge cases
“About 5% of the code I wrote myself. The rest was Claude, with my review and iteration.”
The Quality Question
AI-generated code has a reputation for bugs.
“I reviewed everything. Line by line for critical sections. Behavior testing for UI. But the quality was surprisingly good.”
Claude’s Swift was idiomatic. It followed Apple’s conventions. The SwiftUI was modern, using the latest APIs.
“Better than some contractors I’ve worked with. Cleaner than a lot of code I’ve reviewed on other projects.”
The Iteration Pattern
Not every generation was correct.
Claude would produce something. Indragie would test it. Find an issue. Describe the problem. Claude would fix it.
“The back-and-forth was constant. Five iterations on a single component wasn’t unusual.”
But each iteration was fast. Minutes, not hours. The total time was dramatically less than manual coding.
The Architecture Benefits
The upfront architecture work paid dividends.
“Because Claude understood the overall structure, its implementations fit together. I didn’t spend time fixing integration issues.”
When Indragie described a new feature, Claude knew where it belonged. Knew what protocols to conform to. Knew how to interact with existing systems.
“The architecture served as a contract. Claude implemented to that contract.”
The Testing Approach
Indragie used Claude for test writing too.
“I’d describe the behavior I wanted to verify. Claude would write XCTest cases.”
The tests caught bugs before they shipped. They also documented expected behavior. When Claude refactored code, the tests ensured nothing broke.
“Having Claude write tests for Claude’s code created a useful feedback loop.”
The Swift-Specific Insights
Some aspects of macOS development were harder for Claude.
“AppKit has quirks. Some older APIs have non-obvious usage patterns. Claude occasionally got these wrong.”
For modern SwiftUI, Claude excelled. For legacy AppKit integration, more human guidance was needed.
“The newer the API, the better Claude handled it. Which makes sense — more modern documentation in its training.”
The Debugging Sessions
When things broke, debugging was conversational.
“I’d describe the symptom: ‘The window doesn’t resize correctly when the preference is changed.’ Claude would analyze, suggest causes, propose fixes.”
Sometimes Claude’s first guess was wrong. But the diagnosis conversation often led to understanding even when the fix was manual.
“Claude was good at narrowing down possibilities. Even when I had to implement the fix myself.”
The App Store Submission
Eventually, the app was ready.
App Store review requirements. Privacy descriptions. Sandboxing considerations. Screenshot generation.
“Claude helped with the submission text too. Marketing copy, feature descriptions, even the privacy policy draft.”
The app passed review on the first submission. No rejections. No back-and-forth with Apple.
The Time Accounting
Indragie estimated the time investment.
With Claude: a few weeks of part-time work.
Without Claude: several months of focused effort.
“The velocity difference was probably 5-10x. Not just faster coding — faster iteration, faster debugging, faster everything.”
The time saved wasn’t just coding time. It was decision fatigue avoided. It was boilerplate eliminated. It was focus preserved for the parts that mattered.
The Cost Analysis
Using Claude’s API for this volume of code generation had costs.
“Maybe a few hundred dollars total. For a production app. That I’d charge for.”
The economics were absurdly favorable compared to traditional development costs. Contractor rates. Employee salaries. The alternative costs made Claude’s usage fees trivial.
The Learning Effect
Building with Claude taught Indragie things.
“Claude would implement patterns I hadn’t considered. I’d read the code, understand it, and add it to my own knowledge.”
The collaboration was educational. Each feature Claude built was a lesson in how it could be done.
“I became a better Swift developer by reviewing Claude’s Swift.”
The Limitations Acknowledged
The approach had limits.
“For truly novel problems — things Claude had never seen in training — I had to step in more. The 95% number depends on working with well-documented domains.”
SwiftUI is extensively documented. macOS app patterns are established. Claude had training data. For cutting-edge, undocumented APIs, the human percentage would have been higher.
The Reproducibility Question
Could others do this?
“Yes, but with caveats. You need to know enough to evaluate Claude’s output. To catch mistakes. To direct iteration.”
The approach worked because Indragie could recognize good Swift from bad. Could identify architectural flaws. Could debug when things went wrong.
“Claude amplified my existing skills. It didn’t replace the need for them.”
The Philosophical Shift
Building the app changed how Indragie thought about development.
“I used to think of coding as crafting each line. Now I think of it as directing and reviewing. Different skill. Different mindset.”
The role became more editorial. Describe what should exist. Evaluate what’s generated. Guide toward correctness.
“The code still matters. But my relationship to producing it has changed.”
The Final Product
Context shipped. Users bought it. Reviews were positive.
A production macOS app. Twenty thousand lines. Ninety-five percent generated.
“If you’re using the app, you can’t tell which lines Claude wrote. That’s the point. It’s just software that works.”
The provenance of code — human or AI — mattered less than its quality. And the quality was there.
