Shipping a macOS App Built Almost Entirely by Claude Code: The Context Project Journey

The Evolution of AI Coding Tools and the Arrival of Claude Code

Author Indragie Karunaratne has been developing Mac software for a long time, but this time he had a truly special experience. He developed and shipped a native macOS app (Context) using almost 100% Claude Code, an AI coding agent. Out of 20,000 total lines of code, fewer than 1,000 were written by hand.

"Context was built almost 100% with Claude Code. Out of 20,000 lines, I wrote fewer than 1,000 by hand."

This article details the journey, the tool selection process, the pros and cons of Claude Code, and how to get the most out of AI coding agents, all in chronological order.

1. From Copilot to Claude Code: The Shift in AI Coding Tools

The author's first encounter with AI coding tools was GitHub Copilot. Built into VS Code, it impressed by going beyond autocomplete to suggest entire function implementations. But the developer still had to do most of the work.

Then competitors like Cursor and Windsurf emerged, ushering in "agent mode" where AI repeatedly reads, builds, and tests code, handling increasingly complex tasks.

In February 2025, Claude Code appeared. Rather than "bolting AI onto" an existing IDE, it was an entirely new terminal-based IDE with nothing but a prompt input, where AI drives all the work.

"The idea that AI wasn't assisting the IDE but replacing it entirely felt refreshing -- I had to try it."

2. Starting Yet Another Side Project

Like many developers, the author had plenty of unfinished side projects. He could build prototypes, but the final 20% of polish was so grueling that he hadn't shipped a project in six years.

This time, he decided to build a native macOS app for debugging MCP servers. The existing MCP server testing tools were clunky, and as a Mac developer, he wanted to build something better himself.

3. Claude Code's Coding Abilities

Claude Code (running the latest Sonnet 4 and Opus 4 models) genuinely writes good code. It's not the best programmer in the world, but it produces results far above those of an average developer.

Claude can handle tasks like:

Navigating and understanding relevant source code within a project
Identifying code style and design patterns
Reading additional documentation and specifications
Generating feature implementation code and test code
Running builds and tests, iterating on failures
Identifying and fixing bugs from screenshots or console logs

"Imagine a new employee showing up with zero context and delivering a complete feature in minutes."

4. Claude Handles Swift 'Okay' and SwiftUI 'Well'

Building the app with the latest Swift 6.1 and SwiftUI, the author tested how well Claude handles Swift. Swift has less training data, so it's slightly weaker, but Claude handles features up to Swift 5.5 comfortably. It occasionally confuses modern frameworks with legacy Objective-C APIs.

SwiftUI code generation is quite good, though the initial output can be rough. Iteratively asking to "make it more beautiful" produces increasingly polished UI.

"Claude's SwiftUI code is generally accurate, but ugly at first. With repeated improvement requests, you get genuinely usable UI."

Complex UI code sometimes trips up the Swift compiler on type inference, but Claude handles this well by breaking the code into smaller pieces.

Simply adding rules to a CLAUDE.md file like "use only the latest APIs," "prefer SwiftUI," and "follow Apple design guidelines" dramatically improves results.

5. "Make It More Beautiful" Is All You Need

Even when Claude doesn't create pretty UI at first, simply saying "make it more beautiful, elegant, and easy to use" yields surprisingly good results.

Just saying "make the UI more beautiful" produces genuinely decent results.

Also, when UI bugs or improvements are needed, pasting a screenshot into Claude gives immediate feedback and fixes.

6. The Key Is 'Context Engineering'

Previously, prompt engineering was considered critical, but with the latest models, context engineering has become more important. In other words, how well you provide the information (context) AI can reference determines the quality of the output.

Claude offers a 200,000-token context window, but as conversations grow, it automatically summarizes (compacts) and carries over to a new context. Important information can be lost in this process, so providing only the necessary information as efficiently as possible is key.

"The latest models understand imperfect input well, but ultimately you're fighting the limits of the context window."

7. 'Priming' the Agent

To get better results from Claude, it's effective to 'prime' it by having it read relevant source code, documentation, and specifications before starting work.

For example, having it read and summarize multiple source files and web specifications, then working from that summary, produces much better results.

"When you ask Claude to read and summarize relevant sources and documentation, it understands better and proceeds more effectively."

This process is especially essential when using the latest APIs or external libraries.

8. AI Can't Read Your Mind -- Clear 'Specs' Are Needed

When delegating feature implementation to Claude, detailed specifications (requirements) are essential. Demos suggesting you can build an "entire app" with a one-line prompt are really just prototype-level at best.

"If you want real features, you need proper specs. They don't have to be polished documents -- casual bullet points work fine."

The time spent writing specs is far shorter than implementing the feature yourself.

9. "Use Ultrathink to Plan First"

Claude sometimes jumps straight into implementation without sufficient background knowledge, producing poor results. In these cases, using keywords like "think," "think hard," "think harder," or "ultrathink" to have it deliberate and plan thoroughly produces much better outcomes.

"Tell it to plan with ultrathink first and not implement until you approve."

This approach uses more tokens, but the quality of results clearly improves.

10. Building Feedback Loops

Setting up an environment where Claude can loop through making changes, testing, diagnosing failures, and re-fixing makes development much more efficient.

Build: Swift packages work well with swift build, but Xcode projects may require separate tools (XcodeBuildMCP).
Test: Unit tests work via swift test. UI tests require additional setup.
Bug Fixes: Claude can find bugs from logs, but the user needs to manually operate the app and paste the logs.
UX Improvements: Pasting screenshots enables iterative UI refinement.

11. Claude Code Does More Than Write Code

Claude Code can be used for various tasks beyond coding. For example, it can edit app copy, suggest feature roadmaps, and generate realistic mock data when real data isn't available.

"Mock data generation was so easy that I could polish the UI even without real data."

Mock data proved especially helpful when testing the diverse capabilities of MCP servers.

12. High-Quality Automation, Now Almost Free

The final 20% of shipping an app -- build, code signing, notarization, packaging, and other complex automation tasks -- is the hardest part. Previously, you'd have to write scripts manually with tools like fastlane, but this time Claude created a 2,000-line Python automation script.

Environment checks
Automatic changelog and release notes generation
Build, code signing, notarization, DMG packaging
Sparkle appcast generation for auto-updates
GitHub release and Sentry symbol uploads

"The automation script completed in just a few hours saved me dozens of minutes every release."

13. The IDE of the Future Will Be Completely Different

For this project, the author used only Claude Code and GitHub Desktop. The file tree, source code editor, and extensions of traditional IDEs were barely needed.

"If this is what AI coding agents look like at their worst, I'm convinced the IDE of the future will look completely different from today."

The future IDE will focus on setting up agent context and building feedback loops, and may not even center around a source code editor.

14. Finally Able to Ship Side Projects Again!

The most gratifying part of this journey was that he could now finish and ship side projects again. It felt like gaining five extra hours a day, at a cost of roughly $150 per month.

"I can now finish side projects and put them out into the world again. It feels like gaining five extra hours every day."

Key Concepts Summary

Claude Code: Terminal-based AI coding agent, generating nearly 100% of the code automatically
Context Engineering: The key is providing AI with the right reference information (docs, code, specs)
Priming: Having the agent read and summarize relevant materials before work to improve understanding
Detailed Specs: Clear requirements are essential for AI to function properly
Feedback Loops: Iterative structures for automated building, testing, bug fixing, and UI improvement
Automation: AI writes high-quality automation scripts for build/release/deployment
The Future IDE: Shifting from source-code-editor-centric to agent-centric UX

This article offers a vivid firsthand account of practical AI coding agent usage and how the development environment will evolve. With AI, an era where anyone can complete great projects more easily and quickly is dawning.