AlexWrites
← Back to articles
Dev, AI

Claude Code: how AI wrote 80% of my 55,000-line iOS app

Alexandre
Alexandre
··
Reading time: 8 min
55,000 lines of Swift. 300 files. One dev. And 80% of the code written with Claude Code.
I'm not going to pretend it's magic. Some days Claude saved me 6 hours, and some nights I spent 3 hours debugging code it generated because it had reversed a business logic condition. But overall, without this tool, Livate probably wouldn't exist.

Why Claude Code and not the others

Before, I used ChatGPT. You copy code, explain the context, grab the answer, paste it into Xcode. It works, but it's slow and you lose context with every exchange.
Claude Code lives in your terminal. It reads your files, runs commands, modifies code directly. The difference is that it sees the project structure, not just the file you show it.
When I ask it to modify a ViewModel, it first reads the related files, checks the project conventions, and produces code that respects the existing architecture. Not generic code copy-pasted from Stack Overflow.
By the way, Apple just integrated Claude directly into Xcode 26.3. I already use Claude Code daily to dev Livate, but built into the IDE it's a whole other level.

The CLAUDE.md: 177 lines that made all the difference

What I should've figured out sooner: without context, AI does whatever it wants. With context, it actually delivers.
The CLAUDE.md file at the project root is your living documentation. Claude reads it automatically at each session. Mine contains:
## Common commands

# Start the full stack (PostgreSQL + Frontend + Backend)
cd backend && docker compose up -d

# Rebuild after changes
docker compose build livate_siteweb_backend

## Code conventions
- Backend: snake_case files, camelCase variables, PascalCase classes
- Frontend: PascalCase components, camelCase functions
- Commits: feat:, fix:, refactor:, test:, docs:
The real game-changer was adding recurring mistakes. Early on, Claude kept using @ObservedObject instead of @StateObject in my SwiftUI views, which crashed the navigation. Now I have a section in the CLAUDE.md with the right patterns. It doesn't make that mistake anymore.
According to Anthropic, their own internal teams use CLAUDE.md extensively. The security team adopted it to automate Terraform code reviews.

My agent team: 6 specialists in one terminal

The setup I use is pretty beefy. In the .claude/agents/ folder of my project, I have 6 specialized agents:
AgentRoleModel
maestroOrchestrator, analyzes the request, delegates to other agentsOpus
impl-iosSenior iOS dev, implements in SwiftUI/Swift 6+Opus
impl-backendBackend dev, Express/TypeScript/SequelizeOpus
reviewQuality gatekeeper, 3 modes: pre-commit validation, scored review /100, pre-merge checkSonnet
testQA, identifies relevant tests, runs them, analyzes resultsHaiku
auditAuditor, scans the codebase, tech debt, trendsSonnet
The maestro is the entry point. It doesn't code. It analyzes what I'm asking, decides which agent to mobilize, and coordinates everything. Its description:
You are the Maestro of the Livate team.
You do NOT code. You do NOT write specs.
You analyze, decide, delegate, coordinate,
and validate results.
When I request a feature, the maestro launches the impl-ios agent to code, then review to validate, then test to verify. Each agent has its own context, which prevents saturation.
A real example from last week: I asked to add auto-generated Open Graph images on the blog + similar articles at the bottom of the page. Claude split that across 3 parallel agents, created 4 files, modified the SEO metadata, ran the build. Result: 0 errors, 20 minutes. By hand, it would've taken me the whole afternoon.

Slash commands: my daily shortcuts

In .claude/commands/, I have Markdown files that become commands. My /commit for example:
Prepare and create a Git commit.

Rules:
- Check git status
- Refuse to commit secrets (.env, credentials)
- Message format: feat/fix/refactor/test/docs

Steps:
1. git status
2. git diff
3. git add <relevant files>
4. git commit -m "<type>: <message>"
5. git status to confirm
I type /commit in the terminal, Claude analyzes the changes, generates a clean commit message and pushes. No more thinking about formatting.
I also have /branch, /merge, /status. Small things, but when you use them 10 times a day, the time savings add up.

Skills: giving Claude real abilities

Slash commands are things you decide when to trigger. Skills are different: Claude activates them on its own when it detects they're relevant. Anthropic published a comprehensive 32-page guide on the topic in January 2026, and the official docs explain the mechanics well.
In practice, a skill is a folder in .claude/skills/ with a SKILL.md file containing YAML metadata (name, description, when to activate) and Markdown instructions. The folder can also include scripts, templates, and reference files. Claude reads the description and decides on its own whether to load the skill based on what you're asking.
.claude/skills/
  ios-simulator-skill/
    SKILL.md                    # Entry point (metadata + instructions)
    scripts/
      build_and_test.py         # Build + tests
      screen_mapper.py          # Analyzes current screen
      navigator.py              # Semantic navigation
      accessibility_audit.py    # WCAG accessibility audit
      visual_diff.py            # Screenshot comparison
      push_notification.py      # Push notification testing
      ...                       # 21 scripts total
I use ios-simulator-skill on the Livate iOS project. It's 21 Python scripts that drive the simulator: build, screen navigation, gesture simulation, accessibility auditing, screenshot capture. I say "check that the Start button is accessible", Claude loads the skill, runs accessibility_audit.py, and tells me if the VoiceOver label is missing. Without this, I'd have to explain the simulator mechanics to it every session.
The difference from a slash command: the skill bundles all its context. The SKILL.md describes when to activate, the scripts are there, the conventions are documented. Claude doesn't need you to hold its hand.

The times Claude got me in trouble

I'm not going to sugarcoat it, it's not always smooth sailing.
Over-engineering. The real problem with code agents isn't basic bugs. It's that they over-engineer your requirements. You ask for a simple sort on a list, you end up with a configurable sorting system with 3 priority levels and an enum for each direction. I learned to be ultra-specific in my requests: "do exactly this, nothing more."
Code duplication. Claude loves creating helpers, utils, abstractions. Except it doesn't always know what already exists in the project. Result: 3 functions doing the same thing across 3 different files. Now I systematically ask it to search for similar functions before creating anything.
Security vulnerabilities. This one's the most insidious. An agent will produce code that works, compiles, passes tests. But forgets to sanitize an input or exposes an endpoint without auth. It's the kind of thing you don't catch at first glance. Anthropic actually launched Claude Code Security in February 2026: an AI scanner built into Claude Code that has already identified over 500 vulnerabilities in open-source projects. It's a good habit to run a security audit after every sensitive feature.

My daily workflow

A dev session on Livate looks like this:
1. I launch claude in the terminal. It loads the CLAUDE.md and the agents.
2. I describe what I want, in plain language, like talking to a colleague. Something like: "add a refresh button on the admin marketing page with the RefreshCw icon from Lucide, it should refresh the stats and users with a spinner while loading."
3. Claude explores the relevant files, understands the existing pattern (React Query, custom hooks), and produces code that's consistent with the project.
4. I review and iterate. "The badge is too big in the cards", "rename it to Livate App Tracking". It adjusts without asking for the full context again.
5. Quality gate: bash scripts/quality-gate.sh -> lint + build frontend + backend. If it's green, commit and push.
The whole thing takes 1 to 2 hours for a feature that would've taken me 1 to 2 days alone, without AI.

Some numbers

MetricValue
Lines of Swift (iOS app)55,000+
Swift files300
% coded with Claude~80%
Custom agents configured6
Slash commands4
Average time per feature1-2h instead of 1-2 days
According to the Anthropic 2026 Agentic Coding Report, code agents are evolving from individual assistants to coordinated teams. That's exactly what I experience every day.

5 things to know if you're getting started

1. Invest 2 hours in your CLAUDE.md. Include the architecture, conventions, Docker commands, and especially recurring mistakes with their solutions. This had the biggest impact on my project.
2. One feature = one session. /clear between each feature. A clean context produces better code than one polluted by the 3 previous features.
3. Let Claude explore before coding. Before saying "implement X", ask "how does Y work in the project?". It'll read the files, understand the patterns, and its implementation will be consistent.
4. Commit before every refactor. That way, when Claude breaks 12 dependencies trying to "clean up", you roll back in 10 seconds.
5. The first draft is never perfect. And that's OK. Claude produces a first draft in 30 seconds, but the value is in the iteration. "Reduce the padding", "add a fallback if the API fails". Each iteration takes 10 seconds instead of 10 minutes by hand.

The dev job isn't dead, it's evolving

The line of code has lost its value. Anyone can generate 500 lines of Swift in 30 seconds with an agent. That's a done deal.
What's gained value is everything else. Knowing why you're building this product. Having a clear product vision. Understanding your users' real needs. Orchestrating agents without getting dragged into over-engineering. Reviewing code you didn't write and spotting what's off.
Devs don't spend 8 hours a day typing in their IDE anymore. They give intentions, structure context, validate, iterate. They're agent pilots. The value has shifted from "how" to "why."
8 months of dev. 55,000 lines. An app in production. A blog. A backend. A custom analytics system. All solo. Not because AI did everything for me, but because I knew exactly what to ask it and why.
And you, what AI do you code with? If you use Claude, Cursor, Copilot or something else, I'm curious to hear about your setup. Send me a message on Twitter/X or drop a comment.
Alex

Key takeaways

  • In 2026, a dev doesn't spend 8 hours a day writing code. They give intentions, structure context, validate, iterate. They're agent pilots.
  • The CLAUDE.md is your best investment: 177 lines of context that turn a generic agent into a specialist for your project.
  • 55,000 lines of Swift, 80% coded by AI. But the real value is in the 20% the human brings: product vision and critical thinking.
  • An agent generates code that compiles. Not code that survives 10,000 users. Human review remains essential.
  • 6 specialized agents beat one generalist: maestro, impl-ios, impl-backend, review, test, audit.
← Back to articles

Related articles

Comments

Comments

Got a take on this article?

Create a free account in 10 seconds to comment, like, and get the next articles straight to your inbox.

Don't have an account yet?

This site uses cookies for analytics and advertising. No personal data is sold. Learn more