skills

Algorithmic engineering theory, language-agnostic: complexity analysis (time/space, amortized), data-structure selection, algorithm families (divide & conquer, dynamic programming, greedy, graph, string), correctness reasoning with invariants, and space-time/approximation tradeoffs. Use when choosing a data structure, analyzing or reducing complexity, solving an algorithmic problem, reviewing code with non-trivial loops/recursion, or reasoning about scalability limits of an approach.

Local, searchable Apple developer documentation via the apple-docs CLI and MCP server (DocC, Human Interface Guidelines, App Store Review Guidelines, Swift Evolution, Swift Book, WWDC sessions, sample code, SF Symbols). Use whenever an answer depends on exact Apple API behavior, availability, HIG/review-guideline wording, or WWDC content — before trusting training memory. Also use to set up the tooling: detect whether the MCP server or CLI is available and propose installation if not.

Apple platform API adoption for the iOS 26 / macOS 26 SDK generation: Liquid Glass (SwiftUI, UIKit, AppKit, WidgetKit), Swift 6.2 features (InlineArray, Span, concurrency updates), Foundation Models (on-device LLM), Visual Intelligence, AppIntents, StoreKit, SwiftData inheritance, AlarmKit, 3D Charts, MapKit GeoToolbox, AttributedString, visionOS widgets. Use when adopting, migrating to, or asking about these platform APIs. For SDK 27 SwiftUI changes use swiftui-whats-new-27; for general SwiftUI use swiftui.

Secure coding and security review for Apple platforms: threat modeling (STRIDE, attacker profiles), Keychain and Secure Enclave storage, CryptoKit cryptography, network security (ATS, certificate pinning, TLS), input validation (deep links, URL schemes, WebView hardening), jailbreak/integrity checks, and security code-review methodology. Use when writing or reviewing security-sensitive code (auth, storage, crypto, network handlers, deep links). For Xcode build-setting hardening (Enhanced Security, bounds safety) use audit-xcode-security-settings.

Guide for the C -fbounds-safety language extension. Covers the language model, pointer annotations, adopting bounds-safety in existing C code, compiler build settings and modes, and runtime debugging of bounds violations.

Perform rigorous, team-calibrated code reviews for iOS (Swift/SwiftUI) and Android (Kotlin/Compose) projects. Automatically detects platform from file extensions and applies platform-specific review rules. Covers correctness, architecture, type safety, naming, testing, simplification, UI patterns, and PR process. Also integrates a simplification-first philosophy to strip unnecessary complexity. Use when reviewing code, PRs, or code snippets for any iOS or Android project. Triggers on "code review", "PR review", "review my PR", "strict review", "senior review", "thorough review". Not for pure refactoring requests without review context.

Request second-opinion analyses from other installed AI CLIs (Claude, Codex, Gemini) and synthesize the result. Use when decisions are high impact, architecture tradeoffs are unclear, or you want external challenge before implementation.

Systematic, hypothesis-driven debugging in any language: reproduce, isolate, form falsifiable hypotheses, bisect, find root cause, fix minimally, and lock the fix with a regression test. Use when encountering ANY bug, failing test, crash, flaky behavior, or unexplained output — BEFORE proposing fixes. Also use when a previous fix didn't work or a bug keeps reappearing.

Language-agnostic development practices: disciplined refactoring, small reviewable changes, trunk-based delivery and DORA-style flow, dependency hygiene, verification-before-completion, and working-in-legacy-code strategy. Use when refactoring, structuring a change into commits/PRs, deciding branching or release flow, adding/upgrading dependencies, or closing out a task ("is this actually done?"). For test methodology use testing; for review checklists use code-review.

Cross-platform graphics theory and rendering engineering: shader math, optical physics, light transport, BRDF/BSDF models, Monte Carlo sampling, PBR, coordinate systems, numerical stability, neural rendering (3DGS, NeRF), ReSTIR/DDGI real-time GI, spectral rendering, differentiable rendering (Mitsuba 3), GPU compute advances (mesh shaders, work graphs, bindless), volumetric rendering, advanced sampling (blue noise, path guiding), color science (ACEScg, Oklab, AgX, HDR), temporal techniques (DLSS/FSR/XeSS), and WebGPU. Use when working on rendering math, cross-platform shader code (Vulkan, WebGPU, GLSL, HLSL, WGSL), validating physical correctness, solving graphics math problems, implementing neural rendering pipelines, or optimizing GPU-driven rendering. For Apple Metal specifically, use the metal skill.

How code actually runs on hardware and the OS, language-agnostic: cache hierarchy and data layout (cache lines, locality, false sharing, AoS vs SoA, alignment), CPU microarchitecture (branch prediction, ILP, SIMD, speculative execution), atomics and memory ordering, OS scheduling (preemption, context switches, priorities, priority inversion, QoS, heterogeneous P/E cores), and threading runtime models (thread pools, work stealing, blocking hazards). Use when diagnosing cache- or scheduling-related slowness, false sharing, lock contention, priority inversion, hangs, or when writing performance-critical or lock-free code. Methodology parent: performance-engineering (measure first).

Memory safety theory and practice, language-agnostic: spatial/temporal violation classes (buffer overflow, use-after-free, double-free, dangling pointers, uninitialized reads, type confusion), ownership and lifetime models (RAII, borrow checking, reference counting, GC, exclusivity), sanitizers (ASan/TSan/UBSan/MSan), and hardware mitigations (ASLR, W^X, stack canaries, PAC, MTE, CHERI). Use when reviewing unsafe/low-level code, diagnosing memory corruption or crashes (segfault, heap corruption, UAF), choosing ownership strategies, or hardening builds. For C bounds annotations use c-bounds-safety; for Xcode hardening settings use audit-xcode-security-settings.

Metal and Apple GPU engineering: shaders, compute kernels, ray tracing, tile-based deferred rendering architecture, Metal Performance Shaders, BRDF/sampling math, and GPU profiling with Instruments. Use when writing or reviewing Metal shader code, optimizing GPU workloads, or debugging rendering on Apple platforms. For cross-platform graphics theory and non-Metal shading languages (GLSL, HLSL, WGSL, WebGPU) use the graphics skill.

Measurement-first performance engineering in any language: profiling methodology, USE/RED/golden-signals triage, latency percentiles and tail latency, benchmarking discipline, complexity and memory analysis, caching, concurrency throughput, and the optimization order of attack. Use when something is "slow", before/while optimizing code, when designing performance budgets or load tests, or when reviewing changes claimed to improve performance. For SwiftUI rendering use swiftui; for GPU use metal.

Unified planning, routing, and execution skill. Adapts to any scale — decomposing tasks, building project roadmaps, orchestrating multi-phase parallel agent execution with locks and logging, formulating typed XML execution contracts, and dynamically routing requests to the best available skills. Use when the user asks to plan work, decompose tasks, create a roadmap, schedule a project, orchestrate phases, formulate a request, route to skills, or coordinate parallel agent work. Also triggers on complex multi-step development requests spanning multiple files or modules (e.g. "plan and implement", "orchestrate this migration", "decompose this into tasks"). Not for casual conversation, trivial one-line edits, simple single-file changes, or direct questions that can be answered immediately.

Project-specific conventions layered on top of the generic skills: ticket workflow, module structure, design tokens, test utilities, and PR etiquette. Use when working inside a repository to detect and honor its conventions before applying generic guidance, or as a template to encode a team's conventions. Other skills (swift, swiftui, testing, code-review) defer to this skill when present.

Language-agnostic secure coding and vulnerability review grounded in OWASP Top 10:2025, OWASP ASVS 5.0, and CWE Top 25 (2025): input validation, injection, authentication/authorization, secrets handling, supply-chain hygiene, error/exception handling, SSRF, cryptographic misuse. Use when writing or reviewing code that crosses a trust boundary (user input, network, files, third-party data), handling credentials/secrets, adding dependencies, or when asked for a security review in any language. For Apple-platform specifics (Keychain, ATS, entitlements) use apple-secure-coding.

Create, improve, test, install, and manage agent skills for any platform (Claude Code, Codex, Cursor, OpenCode, Gemini CLI, and 30+ others). Use when users want to: create a new skill from scratch or from a conversation, update or optimize an existing skill, run evaluations to test a skill, benchmark skill performance, optimize a skill description for better triggering, install skills from GitHub or curated lists, review or audit a skill, or learn about the Agent Skills open standard. Also use when someone says "turn this into a skill", "make a skill for X", "install skill Y", or "improve this skill".

Swift language and concurrency: API design, SOLID, protocols, generics, typed errors, SPM package structure, naming, async/await, actors, Sendable, tasks, AsyncSequence, Swift 6 strict concurrency and data-race safety. Use when writing, reviewing, or architecting Swift code, fixing concurrency issues, or migrating to Swift 6. Not for SwiftUI views (use swiftui), platform APIs (use apple-platforms), GPU work (use metal), or security reviews (use apple-secure-coding).

SwiftUI development and design engineering: views, state management, @Observable, navigation, sheets, lists, animations, charts, macOS scenes, typography, accessibility (WCAG, Dynamic Type, VoiceOver), design tokens, responsive layout, previews, and performance auditing (hitches, invalidation storms, Instruments). Use when building or reviewing SwiftUI interfaces, designing components, or diagnosing UI performance. Not for UIKit migration (use uikit-app-modernization) or SDK 27 API changes (use swiftui-whats-new-27).

System architecture and DevOps guidance: infrastructure design, CI/CD pipelines (GitHub Actions, Xcode Cloud), observability, monitoring, IaC (Terraform, CloudFormation), container orchestration, progressive delivery, and operational strategy. Use when planning system architecture, deployment pipelines, cloud infrastructure, or reliability/scalability strategy.

Comprehensive testing guidance covering the full lifecycle: before/during implementation (TDD, ATDD, example mapping, property-based testing, contract testing) and after implementation (unit, integration, regression, mutation, snapshot, performance, fuzz, smoke, characterization testing). Use when: writing tests first (Red-Green-Refactor), designing test strategy, performing mutation testing, writing integration/regression tests, using Swift Testing (@Test, #expect, parameterized tests), creating mocks/stubs/fakes, refactoring legacy code with tests, doing property-based testing, snapshot testing, performance benchmarking, fuzz testing, or diagnosing test smells and flaky tests. Not for concurrency testing patterns (use the swift skill concurrency domain).

Generate work documentation for software projects: PR descriptions, work summaries (sprint/release/multi-PR), ticket-system artifacts (user stories, epics, bugs, tasks, spikes), planning-increment artifacts, ADRs, design docs, release notes, and changelogs. Two perspectives: requesting (PM/stakeholder defining work) and reporting (developer explaining done work). Use when the user needs to write PR documentation, summarize work in a repo, create tickets or user stories, define epics or acceptance criteria, write bug reports or post-mortems, document iteration goals, create ADRs or design docs, generate release notes, or bridge product requirements and technical implementation. Triggers: "write a ticket", "summarize this work", "create a story", "document this epic", "write release notes", "what was done", "acceptance criteria", "bug report".

Agentic coding workflows for Xcode projects (Xcode 26.3+/27): building, testing, and running apps from the CLI (xcodebuild, xcrun, devicectl, simctl), connecting agents to Xcode via MCP (xcrun mcpbridge), Device Hub device management, self-validation loops (build → test → preview → simulator), Xcode skill/AGENTS.md integration, and SDK 27 migration gates. Use when an agent needs to build, test, run, profile, or verify an Xcode project, or when configuring Xcode for agent access.