ios-memgraph-analysis
Use when capturing or analyzing an iOS .memgraph, especially when the task mentions a memory leak, heap growth, persistent memory increase, ownership path, or matched-capture comparison with Apple CLI tools.
Install / Use
npx skills add dpearson2699/swift-ios-skills --skill ios-memgraph-analysisInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of ios-memgraph-analysis
ios-memgraph-analysis scores 85/100 on our quality scale, 2712th of 4,698 Development & Engineering skills we index.
Its SKILL.md is 9.4 KB long, well organised into 15 sections with 2 code examples: a thorough specification that gives an agent plenty to work with.
With 1,143 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-11-05 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 86/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
ios-memgraph-analysis compared with similar skills
All 4 of these similar skills score higher than ios-memgraph-analysis; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| ios-memgraph-analysis (this skill)by dpearson2699 | 85 | 1.1k | 4mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| lobehubby lobehub | 100 | 85.6k | today | MCP Server |
Frequently asked questions
- How do I install ios-memgraph-analysis?
- Run
npx skills add dpearson2699/swift-ios-skills --skill ios-memgraph-analysis. The install tabs above show the steps for each supported agent. - Which AI agents does ios-memgraph-analysis work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is ios-memgraph-analysis safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 86/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is ios-memgraph-analysis still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: ios-memgraph-analysis description: "Use when capturing or analyzing an iOS .memgraph, especially when the task mentions a memory leak, heap growth, persistent memory increase, ownership path, or matched-capture comparison with Apple CLI tools. Covers unambiguous Simulator capture, leaks/heap/vmmap/malloc_history evidence, raw artifact preservation, and same-flow verification. Use debugging-instruments for interactive Xcode Memory Graph, Instruments, generic retain-cycle inspection, or LLDB work."
iOS Memgraph Analysis
Use memory graphs to prove why memory survives a defined lifetime boundary. Separate unreachable leaks from reachable growth, preserve raw tool output, and verify the same app-owned type and ownership path after a fix.
Contents
Boundary
This skill owns .memgraph capture and command-line ownership/growth analysis.
Use the Memory Graph Debugger or Instruments when their interactive graph and
allocation timeline are the primary task. Use source review for a suspected
closure capture only after runtime evidence identifies the lifetime or path.
Evidence Model
Do not collapse these conditions:
- Unreachable leak: allocated memory no longer has a path from a live root. An isolated strong cycle can be unreachable and still consume memory.
- Reachable but abandoned state: a live root still retains objects the user
flow no longer needs.
leaksmay correctly report zero. - Expected cache or pool: memory survives intentionally and must be judged by its bound, eviction behavior, and pressure response.
- Heap regression or fragmentation: footprint grows because more/larger allocations persist or dirty pages are poorly utilized, without a leak.
Apple's leak scanner uses conservative pointer discovery and incomplete type metadata. Counts can fluctuate, and a zero result does not prove the absence of an ownership bug. Strong evidence identifies the expected lifetime, an app-owned type or allocation, and a credible path or isolated reproduction.
Workflow
1. Define the lifetime before capturing
Name the object that should disappear and the event that ends its useful life.
For example: EditorViewModel should deinitialize after dismissing the editor
and completing pending save work.
Record one deterministic sequence:
- launch or restore a known state;
- take an optional baseline graph;
- perform the feature flow;
- cross the expected release boundary;
- wait for legitimate asynchronous cleanup;
- take the post-flow graph.
Keep build, simulator/device, data, Malloc Stack Logging setting, and repetition count stable. Malloc Stack Logging adds valuable allocation backtraces but also overhead; compare only runs with the same setting.
2. Capture a graph without guessing the process
Xcode can export a graph from the Memory Graph Debugger. For a running Simulator app, use the helper from this skill:
mkdir -p /tmp/myapp-memory
mkdir /tmp/myapp-memory/run-01
python3 scripts/capture_sim_memgraph.py \
--bundle-id com.example.MyApp \
--output-dir /tmp/myapp-memory/run-01 \
--pretty > /tmp/myapp-memory/run-01/capture.json
The per-run mkdir must fail if the capture directory already exists. Use a
new run name rather than mixing stale evidence with a retry.
Pass --udid when more than one Simulator is booted. The helper accepts only
one exact launchd label and PID; zero or multiple matches are errors. It runs the
host leaks --outputGraph command, retains stdout/stderr, and writes a manifest.
Do not replace this with pgrep | head -1 or a substring match.
Capturing suspends the process. Do not use capture latency as performance data.
3. Preserve raw output and build a bounded summary
MEMGRAPH=$(jq -er \
'select(.status == "captured") | .memgraph | select(type == "string" and length > 0)' \
/tmp/myapp-memory/run-01/capture.json)
test -s "$MEMGRAPH"
python3 scripts/summarize_memgraph.py \
"$MEMGRAPH" \
--artifact-dir /tmp/myapp-memory/run-01/analysis-raw \
--app-image 'MyApp|MyFeatureKit' \
--trace-limit 3 --group-by-type --pretty \
> /tmp/myapp-memory/run-01/analysis.json
Read the exact graph path from the preserved capture report; do not guess a
timestamped filename. The helper creates a dedicated raw-artifact directory,
refuses to reuse it, runs leaks --list, and parses only a conservative subset
of its text. --app-image marks candidate rows; it does not prove ownership.
--trace-limit runs bounded
leaks --traceTree=<address> queries. Add --reference-tree when aggregate
root paths are more useful than individual leaked addresses. With
--group-by-type, that reference-tree query is grouped in the same invocation.
Exit statuses 0 and 1 from leaks remain analyzable; a primary status above 1
fails the summary, while optional-query failures are preserved and warned as
unusable without discarding a valid primary summary.
Apple does not publish these text formats as stable machine schemas. Treat parse warnings as a reason to inspect the raw artifacts, not to loosen the parser until it emits a desired answer.
4. Find the first actionable app-owned edge
Start with an app-owned leaked type or allocation stack. Inspect:
- the leak's object graph and Malloc Stack Logging backtrace, when present;
- a bounded
--traceTree=<address>for objects that reference one address; --groupByTypeto compress repeated types and reveal a retained payload;--referenceTreefor a top-down view when the responsible address is unclear;- source code for the first strong edge controlled by the app.
An unreachable self-cycle may have no live root in traceTree. Use the grouped
leak graph plus source verification or reduce the behavior to an isolated
reproduction. Never invent a root path that the graph does not contain.
5. Investigate growth when leaks is empty
Use matching baseline and post-flow graphs, locate the growing region, compare
object types, then trace a suspicious address back to an app-owned edge. The
evidence goal is persistent reachable growth across the same lifetime—not a
lower RSS value or a single large snapshot. Load
reachable-growth.md only for this empty-leak
branch; it contains the ordered vmmap, heap, leaks, and malloc_history
queries and their logging-dependent alternatives.
6. Fix and verify the same lifetime
Prefer the narrowest ownership correction: break the unintended strong edge,
cancel work that owns the object, remove an observer, bound/evict a cache, or
release a large buffer after its last use. Use weak when the reference may
legitimately become nil; use unowned only with a proven lifetime guarantee.
Repeat the identical flow. A fix is supported when the same app-owned type/path disappears or the pre/post growth attributable to it is removed across repeated runs. Lower RSS, a smaller graph file, or a lower aggregate leak count alone is not proof.
Ownership Decisions
| Evidence | Next action | |---|---| | App type in a root cycle | Inspect both strong edges and allocation stack. | | No root for a leaked address | Inspect grouped cycle evidence and isolate the flow. | | Live root retains dismissed feature state | Follow the path to the first app-owned edge. | | Zero leaks but repeated malloc growth | Diff baseline/post heap objects. | | Framework object dominates | Find the app-created owner, input, or call frequency. | | Growth stabilizes at a documented bound | Test eviction/pressure behavior before changing it. |
Common Mistakes
- Declaring the app leak-free because
leaksreturned zero once. - Selecting the first PID or Simulator from an ambiguous list.
- Enabling Malloc Stack Logging in only one side of a comparison.
- Treating a parser's best-effort type column as an API guarantee.
- Pasting enormous reference trees into a report without finding an app edge.
- Fixing every closure with
[weak self]without reasoning about lifetime. - Claiming success from graph size, RSS, or total-count changes without proving the target lifetime and ownership path.
Review Checklist
- [ ] The object and expected release boundary are explicit.
- [ ] Baseline and post-flow graphs use the same build, runtime target, data state, deterministic flow, cleanup wait, repetitions, and Malloc Stack Logging setting.
- [ ] Simulator, bundle identifier, process label, and PID are unambiguous.
- [ ] Original graph and raw command outputs are preserved.
- [ ] Current installed-tool help confirms version-sensitive command shapes.
- [ ] Leak, reachable growth, expected cache, and fragmentation are separated.
- [ ] The finding names an app-owned type/allocation and credible path.
- [ ] Missing type metadata or conservative-scanner limits are disclosed.
- [ ] The fix changes one ownership/lifetime cause.
- [ ] Verification repeats the same flow and evidence query.
References
- Reachable growth when
leaksis empty — matched-graph comparison and address-to-owner workflow - Gathering information about memory use
- Detect and diagnose memory issues — WWDC21
- Analyze heap memory — WWDC24
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
lobehub
85.6k🤯 LobeHub - Super-Agents on Your Team. Add super-agents to the chats your team already uses.They take on work by themselves and get better every week.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
