xcode-compilation-analyzer

Analyze Swift compile hotspots from build timing summaries and frontend diagnostics.

7|8|Updated Jan 22, 2026
One-click install
npx skills add https://github.com/omarshahine/Apple-PIM-Agent-Plugin --skill xcode-compilation-analyzer-omarshahine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: xcode-compilation-analyzer
Source: https://github.com/omarshahine/Apple-PIM-Agent-Plugin/tree/main/.claude/skills/xcode-compilation-analyzer
Command: npx skills add https://github.com/omarshahine/Apple-PIM-Agent-Plugin --skill xcode-compilation-analyzer-omarshahine

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Analyze Swift and mixed-language compile hotspots using build timing summaries and Swift frontend diagnostics, then produce a recommend-first source-level optimization plan. Use when a developer reports slow compilation, type-checking warnings, expensive clean-build compile phases, long CompileSwiftSources tasks, warn-long-function-bodies output, or wants to speed up Swift type checking.

Core Features & Use Cases

  • Identify and rank the biggest compile bottlenecks using Build Timing Summary and -Xfrontend diagnostics.
  • Produce a prioritized plan that targets wall-clock impact and parallelism, not just raw seconds.
  • Use cases include investigating slow modules, large bridging surfaces, and recurring type-check slowdowns in Swift.

Quick Start

Run the diagnose_compilation.py script against your Xcode project to surface compilation hotspots and generate a diagnostics artifact.

Frequently Asked Questions about xcode-compilation-analyzer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify and fix slow Swift compilation hotspots in Xcode?

To identify slow Swift compilation hotspots, parse the Xcode Build Timing Summary and Swift frontend diagnostics to rank compile bottlenecks by wall-clock impact. This generates a prioritized source-level optimization plan targeting slow CompileSwiftSources phases and heavy type-checking workloads.

Why does my Xcode project have a slow CompileSwiftSources phase and how can I diagnose it?

A slow CompileSwiftSources phase is diagnosed by parsing per-file timing data and -Xfrontend diagnostics like warn-long-function-bodies. This surfaces the specific files causing expensive incremental builds or heavy type-checking workloads, allowing targeted optimization.

What is the best way to optimize Swift type-checking warnings for large function bodies?

The best way to optimize Swift type-checking warnings is to analyze -Xfrontend diagnostics and Build Timing Summary data. This prioritizes source-level optimizations based on parallelism and wall-clock impact rather than raw seconds, directly targeting recurring type-check slowdowns.

Can I use Xcode build timing summaries to investigate slow incremental builds in mixed-language projects?

Yes, you can use Xcode build timing summaries to investigate slow incremental builds in mixed-language projects. The analysis evaluates per-file timing data and frontend diagnostics to rank compile bottlenecks across large bridging surfaces and mixed-language modules.

How do I start analyzing Xcode compilation bottlenecks using build timing data?

Start analyzing Xcode compilation bottlenecks by running the diagnose_compilation.py script against your project. It surfaces compilation hotspots from Build Timing Summary data and generates a diagnostics artifact to guide your optimization plan.

What limitations exist when optimizing slow Xcode build times using frontend diagnostics?

When optimizing slow Xcode build times, limitations include relying on accurate Build Timing Summary and Swift frontend diagnostics output. The resulting recommendations prioritize source-level fixes for type-checking and compile phases, but may not address underlying project configuration or dependency issues.