How to use the SwiftUI Performance Audit agent skill

What the skill makes the agent do

The skill runs an audit in a fixed order. First the agent reads your view code and looks for common causes of slow SwiftUI, such as broad state changes that redraw many views, unstable list identities, heavy work inside the view body, layout thrash, oversized images, and over-animated view trees.

If the code review does not settle the question, the agent guides you through recording a trace in Apple's Instruments tool, asks for the trace or screenshots, and analyzes them. It then proposes targeted fixes and a way to re-measure so you can confirm the improvement.

• Code-first review of the views involved in the problem
• Step-by-step Instruments profiling if the code is inconclusive
• Ranked list of likely causes with suggested fixes
• A verification step that compares before and after measurements

Install the skill from a ZIP file

Download the ZIP file for the skill from this directory page. Unzip it into one of two locations. Use ~/.claude/skills/ to make the skill available across your projects, or use the .claude/skills/ folder inside a single project to make it available only there.

If you use the Claude apps instead, you can upload the skill under Settings, then Capabilities, then Skills, rather than placing files on disk.

• Personal install: unzip into ~/.claude/skills/
• Project install: unzip into the project's .claude/skills/ folder
• Claude apps: Settings, then Capabilities, then Skills, then upload

Trigger the skill with natural requests

You do not need a special command. Describe the problem in plain language and include the SwiftUI context. The agent will decide when the skill applies. The source says that if you provide code, the agent starts with the code review. If you only describe symptoms, it asks for minimal code or context before reviewing.

Useful requests name the symptom, the screen, and what you have available, such as the view code or a trace.

• 'My SwiftUI list stutters when I scroll. Here is the view code.'
• 'This settings screen feels slow to navigate to. Can you audit it for performance problems?'
• 'Our iOS app uses too much memory on the photo grid. Walk me through profiling it in Instruments.'
• 'Review this SwiftUI view before our release for performance issues.'

What you need before you start

For the code review, the agent needs the SwiftUI code for the screen or feature, a description of how the data flows through it, and the steps to reproduce the problem. For profiling, you need Xcode and Instruments on your Mac. You can also return a captured Instruments trace or screenshots of the relevant lanes and call tree.

The skill is for SwiftUI. It is not a fit for UIKit, React, or Android apps, and it does not address purely server-side or network delays.

• Xcode and Instruments (for the profiling steps)
• A SwiftUI codebase to review, or a captured Instruments trace or screenshots
• Device, OS, and build configuration details, which the agent will ask for

Profile with Instruments when code review is not enough

When the code review is inconclusive, the agent explains how to collect data. The guidance says to use the SwiftUI template in Instruments on a Release build, reproduce the exact interaction such as a scroll, navigation, or animation, and capture the SwiftUI timeline together with Time Profiler. You then export or screenshot the relevant lanes and the call tree and send them back.

After the trace is analyzed, the agent repeats the same capture after the fixes and compares CPU, frame drops, and memory peak. Use the same interaction each time so the comparison is fair.

• Build in Release configuration and use the SwiftUI template
• Repeat the exact same interaction before and after changes
• Send the SwiftUI lanes and the Time Profiler call tree

Common fixes the agent may suggest

The skill's fixes are concrete. The agent may suggest narrowing state so that only the affected view updates, giving ForEach and lists stable identities instead of values such as UUID() created on each render, and moving formatting, sorting, filtering, or image decoding out of body. It may also suggest downsampling images before display and simplifying layout where possible.

Always check suggestions against your own code before applying them. The agent works from what you provide and may not know your full architecture.

• Cache formatters instead of creating them inside body
• Sort or filter once before the view update, not inside ForEach
• Avoid id: \.self for values that are not stable
• Decode and downsample images off the main thread

Safety notes: scripts and network access

The listing for this skill states that it does not run scripts and does not use the network. Its files are Markdown instructions and reference summaries, including SKILL.md and four reference documents covering Apple's SwiftUI and hang-diagnosis material. The skill is published under the MIT licence.

Even so, read SKILL.md and the reference files before installing any skill you did not write, and keep your source code and traces private if they contain confidential information.

• Listed as not running scripts
• Listed as not using the network
• Files: SKILL.md and four reference documents in references/
• Licence: MIT

Tips for better results

Give the agent a single screen or feature at a time. Include the view code that the screen depends on, and describe the exact steps that cause the slowdown. A recorded trace of the problem interaction is more useful than a general description.

• Name the device and OS where the problem happens
• Describe the exact interaction, such as scrolling a long list
• Ask for a before-and-after comparison so you can confirm the fix worked
• Use the ranked issues list to decide which fix to try first