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.