The Workflow of a Team Using Claude Code for 42 Weeks

Sharing how we achieved a 10x productivity boost using Claude Code on Alarmy, the world's #1 alarm app iOS project.

1

About the Alarmy iOS Project

This is the world's #1 alarm app project, used by over 4 million people every day. It's built on SwiftUI and TCA, and modularized using SPM. Instead of a single architecture, we use a hybrid of TCA, MVVM, and Clean Architecture. We support over 40 languages. For design, our team uses Figma, and we also rely on Notion, Linear, and Firebase.

Why Claude Code?

I found a Slack message from October 22, 2024, where someone first raved about how good Cursor was. The renaissance of agentic coding really kicked off when engineers started using Cursor. We were hooked on it for a while. The iOS team began adopting workflows to develop alongside AI, including mcp, cursorrules, workflow automation, and scripting.

Honestly, until that point, Cursor was just an evolved Copilot; I believe true Agentic Coding started when Claude Code came out. It wasn't just a simple autocomplete tool anymore. By combining local file system access with Unix commands, the coding agent could now directly run tests, builds, linting, and scripts itself. We could easily handle complex tasks within a single workflow and automate repetitive chores like logging issues, creating branches, opening PRs, and drafting PR descriptions. It felt like getting a new engineer teammate who genuinely understood the codebase.

I tracked down the first commit history merged into the iOS repository using Claude Code.

- 최초 Claude 언급: cd569c422 (PR #4617 첫 커밋, 스쿼시 전)
- 작성 시각: 2025-06-26 10:58:30 KST
- 작성자: ***** (Co-authored-by: Claude)
- 메시지: refactor: AppDelegate didFinishLaunchingWithOptions 메서드 가독성 개선
- main 병합: 같은 날 14:54 (스쿼시 커밋 1558281b7)

So, let me share how our iOS team actually sets up and uses Claude Code.

CLAUDE.md

CLAUDE.md is the *code our team values and improves the most. It's not just a simple project manual. It serves as the entry point for automating the entire team's workflow for Claude Code.

CLAUDE.md doesn't contain every single document. Instead, it's designed to detect specific keywords and read the corresponding workflow document. Whether you say "Create a PR" in Korean ("PR 만들어줘") or "pull request" in English, the exact same workflow gets triggered.

...

pr_creation:
    patterns: [PR, 피알, 풀리퀘, 작업 완료, 올려줘 ...]
    action: READ .claude/workflows/create-pr.md
...

...
- AB 테스트 생성/정리 (실험, 베이스라인)
- PR 생성 (피알, 머지, 작업 완료)
- Firebase / TestFlight 배포
- Figma → SwiftUI 변환 (MCP 도구 호출 시 자동)
- Linear 이슈 생성 (리니어, 티켓)
...
특히 Figma MCP 도구(mcp__figma__*)를 호출하면 figma-to-swiftui 스킬이 자동 활성화되어, 하드코딩된 색상/폰트/간격 없이
   AlarmyUI 디자인 토큰으로만 코드가 생성됩니다

Here's a snippet of the CLAUDE.md file we use on the iOS team. We placed the trigger conditions right at the top. We wrote specifications for our most frequently used workflows. After that, we placed the most crucial workflows, with each workflow matching its respective trigger. If you're working as a team, I highly recommend giving team-configuration.md a try. At the very bottom, we added things that need emphasis so Claude Code recognizes them as important.

Workflow Automation

Detailed guidelines for our automated workflows are thoroughly documented in the .claude/workflows folder. We set it up so you can trigger a deployment using natural language like core-qa 채널로 firebase 배포해줘., and the integration with our CI/CD works seamlessly. The CI/CD for our iOS project is built on self-hosted GitHub Actions using Mac Minis. We use GitHub Actions to automate repetitive branching and deployment processes. For example, we minimized Human-in-the-loop (HITL) by setting up a workflow chain where generating release/26.11.0 automatically creates bump-up-version/26.12.0.

Claude Code Skills

• baseline (A/B test baseline skill, error detection, and edge-case handling)

• figma-to-swiftui (skill optimized for our team's shared designs)

• slack (custom skill to utilize the API)

• swiftui-tca-skill (skill for using TCA)

As a team, we only commit and share frequently used skills in the repository. Since the skills used by individuals vary widely and change often, we only include skills that absolutely need to be shared. Teammates are using around 50 skills, such as codex, swift-concurrency, commit, learn, and ios-design. We also use skills like superpowers. Everyone on the team was using around 50 skills or so. But having a ton of skills wasn't the point. What mattered far more was Claude Code successfully selecting the right skill for the job. Continually improving a skill once it's made and setting up skill chains to automate the process itself is what really drove our productivity up.

learn

There's a skill called /learn that we use often. We set up a chain where it thoroughly researches materials on a specific concept or technology, and then uses the /skill-creator plugin to generate a new skill from it.

agent-device

There is one skill we use the most for automation: callstackincubator/agent-device. It's a CLI tool for Android and iOS UI automation. It opens the app in sessions and reads the Accessibility Tree as a compressed snapshot, allowing the agent to grasp the current screen state in a token-efficient way. The key here is that it's not just a one-off automation trick, but something we can leverage as a deterministic and reproducible E2E testing tool.

MCP

We share a .mcp.json file in the project root with the team. Following the same principle as our skills, we keep its usage to a bare minimum. By using mcp, which became officially supported starting with Xcode26.4, you can easily search official documentation using the DocumentationSearch tool. It vastly reduces the chances of failed searches. Since it operates the currently open Xcode, you get a fast feedback loop with incremental builds. You can check out the detailed guide here.

https://developer.apple.com/documentation/xcode/giving-external-agents-access-to-xcode

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.linear.app/sse"
      ]
    },
    "xcode": {
      "command": "xcrun",
      "args": ["mcpbridge"]
    },
    "XcodeBuildMCP": {
      "command": "npx",
      "args": ["-y", "xcodebuildmcp@latest", "mcp"]
    },
     "figma": {
      "url": "https://mcp.figma.com/mcp",
      "type": "http"
    }
  }
}

We automated our CI/CD around workflows using GitHub Actions alongside optimized agents (sub-agents), skills & commands, and mcp. With our communication and issue management process running through Linear and Slack, we set it up so that small-scale tasks—like clear bug fixes or adding event logs—can be completed all the way through deployment and QA in one shot. We automated repetitive tasks and reduced cognitive load. The trade-off is that we now spend more of our brain tokens on the growing number of terminal tabs.

How Claude Code Changed Our iOS Development Workflow

Everything is changing so fast. The automation that seemed impossible yesterday suddenly becomes possible today. In particular, we found that waiting for agent models to evolve was a much wiser call than breaking our backs trying to build complex automation systems ourselves. As an iOS engineer, I no longer run builds directly in Xcode.

Summary

• Using Claude Code as our main agent.

• Keeping shared Agents/Skills/mcp to a minimum across the team.

• Automating repetitive tasks into workflows as soon as we spot them.

• Boosting productivity with Xcode mcp.

• Development is no longer the bottleneck in our sprints.