everything-claude-code-mobile

Build Android project with Gradle, fix errors, generate APK/AAB. Invokes android-build-resolver for issues.

Android code review for Kotlin, Compose, and MVI patterns.

Run Android unit and instrumentation tests. Invokes mobile-tdd-guide for test-driven development.

Generate and verify Compose previews for UI components.

Run Compose UI tests with Espresso. Verify critical user flows.

Cluster related instincts into reusable skills.

Compile the feature, run all tests, and iteratively fix compilation errors and test failures until everything passes. Max 5 iterations.

Build a complete mobile feature from description to running code with E2E tests. Orchestrates 6 phases - planning, implementation, testing, build-fix, quality gate, and verification. Auto-detects platform.

Implement a planned mobile feature using parallel specialized agents for network, data, architecture, UI, and wiring layers. Requires an approved feature plan.

View and manage patterns learned from feature builds. Shows extracted instincts, confidence scores, and feature completeness history.

Plan a mobile feature with architecture decisions, file breakdown, dependency analysis, and test strategy. Produces a structured plan document reviewed by an architecture agent.

Run quality reviews on an implemented feature - code review, security audit, and performance review. Collect findings and apply fixes.

Show the current status of a feature build - which phase is active, what has completed, what remains, and any blockers.

Create all tests for an implemented feature - unit tests (ViewModel, UseCase, Repository), Compose UI tests, and E2E user flow tests.

Run final verification - pass@k test metrics, coverage report, and sign-off. Confirms feature is production-ready.

Fix Gradle sync, dependency conflicts, and cache issues. Invokes android-build-resolver agent.

Export learned instincts for sharing with others.

Import instincts from an exported file.

Show learned instincts with confidence scores.

Build iOS project with Xcode, fix errors, generate IPA. Invokes xcode-build-resolver for issues.

Run iOS tests with xcodebuild, show coverage. Invokes ios-testing patterns.

Build KMP project for all platforms. Invokes kmp-dependency-fix for issues.

Fix KMP dependency conflicts, version mismatches, and Gradle issues.

Run KMP tests across all platforms.

Extract patterns from current session into reusable knowledge.

Run Android Lint, Detekt, and ktlint for code quality.

Unified mobile build command. Detects platform (Android/iOS/KMP) and delegates to appropriate build command. Invokes platform-specific resolver on failure.

Save and restore mobile development checkpoints. Capture build variants, test states, and project state before risky operations.

Plan mobile feature implementation with architecture decisions and task breakdown.

Mobile TDD workflow. Write tests first, implement, refactor. 80%+ coverage required.

Unified mobile test command. Detects platform (Android/iOS/KMP) and delegates to appropriate test command.

Run automated verification loops with pass@k metrics for mobile testing. Executes tests multiple times to detect flakiness.

Detect project type (Android/iOS/KMP), list platforms, show platform info, and delegate to appropriate commands.

Build release APK/AAB with signing, ProGuard/R8, and optimizations.

Run SwiftLint to check Swift code style. Auto-fix issues where possible.

Android build error resolution specialist. Use PROACTIVELY when Gradle sync fails, build errors occur, or dependency conflicts arise. Fixes errors with minimal changes, no architectural edits.

Expert Android code reviewer. Reviews Kotlin code for quality, Compose patterns, coroutine usage, and Google best practices. Use PROACTIVELY after writing Android code. MUST BE USED for all Android changes.

Domain and architecture layer implementer. Creates use cases, domain models, repository interfaces, and DI modules. Android: Koin. iOS: dependency container with protocols. KMP: Koin Multiplatform. Follows Clean Architecture principles.

Jetpack Compose patterns specialist. Guides on state management, recomposition optimization, theming, animations, and Compose best practices. Use when building or reviewing Compose UI.

Data layer implementation specialist. Creates repository implementations, local storage, caching, and data source abstractions. Android: Room. iOS: CoreData/SwiftData. KMP: SQLDelight. Includes offline-first patterns.

Mobile feature planning specialist. Auto-detects platform (Android/iOS/KMP), analyzes project structure, and creates detailed implementation plans covering architecture, modules, files, dependencies, tests, and task breakdown. Use for end-to-end feature planning.

Gradle build system expert. Optimizes build configuration, Version Catalogs, convention plugins, and caching. Use for Gradle setup and optimization.

Expert iOS code reviewer. Reviews Swift code for quality, SwiftUI patterns, Combine/concurrency usage, and Apple best practices. Use PROACTIVELY after writing iOS code. MUST BE USED for all iOS changes.

KMP architecture expert. Designs shared module structures, expect/actual patterns, navigation, and DI for Kotlin Multiplatform projects.

Apple Liquid Glass design specialist for SwiftUI iOS 26+. Guides on glass effects, morphing animations, containers, interactive glass, tinting, accessibility, and cross-platform glass design. Use when building modern Apple UI with Liquid Glass.

Material 3 Expressive design specialist. Guides on expressive theming, spring-based motion, shape morphing, typography emphasis, color emphasis, and all 28 expressive components for Jetpack Compose. Use when building modern, expressive Android UI.

Mobile architecture expert. Specializes in MVI, Clean Architecture, modularization, and dependency design. Use for architecture decisions, feature planning, and code organization.

Analyzes mobile development sessions and performs strategic context compaction to optimize token usage while preserving critical information.

Mobile E2E testing specialist. Creates and runs Espresso tests for Compose, instrumentation tests, and UI automation. Use for end-to-end user flow testing.

Analyzes codebases to extract and categorize mobile development patterns for continuous learning.

Android performance optimization specialist. Reviews for app startup, memory efficiency, rendering performance, and battery optimization.

Mobile security audit specialist. Reviews Android code for security vulnerabilities, data protection, and compliance. Use for security-sensitive features.

Mobile test-driven development specialist. Enforces write-tests-first for Android. Uses JUnit5, Mockk, Turbine, and Espresso with Compose testing. MANDATORY for new features.

Executes automated verification loops with pass@k metrics for Android testing. Detects flaky tests and measures code reliability.

Network layer implementation specialist. Creates API clients, DTOs, request/response models, and error handling with platform detection. Android: Ktor + kotlinx.serialization. iOS: URLSession + async/await + Codable. KMP: shared Ktor in commonMain.

Design cross-platform data models for KMP. Handles serialization, platform-specific fields, validation, and @ObjCName annotations for iOS interop.

SwiftUI patterns specialist. Guides on state management, view optimization, theming, animations, and SwiftUI best practices. Use when building or reviewing SwiftUI UI.

UI layer implementation specialist. Creates screens, ViewModels with state management, and UI components. Android: Jetpack Compose + MVI. iOS: SwiftUI + ObservableObject. KMP: shared ViewModels with platform UI.

UI test implementation specialist. Creates Compose UI tests and SwiftUI tests for screens. Android: Compose Testing + Espresso. iOS: XCUITest + ViewInspector. Tests loading/error/success states, interactions, accessibility.

Unit test implementation specialist. Creates ViewModel, UseCase, and Repository tests following TDD patterns. Android: JUnit5 + Mockk + Turbine + Kotest. iOS: XCTest + async/await. KMP: kotlin.test in commonTest.

Feature integration and wiring specialist. Connects all layers - navigation routes, DI registration, app-level wiring, manifest/plist entries, and inter-feature communication. Runs last after all other implementation agents.

iOS build error resolution specialist. Use PROACTIVALLY when Xcode build fails, Swift Package Manager issues occur, or signing/certificate problems arise. Fixes errors with minimal changes, no architectural edits.

Mobile accessibility patterns for Android and iOS - content descriptions, touch targets, screen reader support, WCAG compliance, dynamic type, and color contrast.

Analytics integration patterns - event tracking, screen tracking, user properties, Firebase Analytics, custom analytics providers, and privacy compliance.

Core Android development patterns for Kotlin, including coroutines, lifecycle management, and functional programming idioms.

App lifecycle patterns - process death handling, SavedStateHandle, ViewModel restoration, lifecycle-aware components, and background task management.

CI/CD patterns for mobile - GitHub Actions workflows for Android/iOS, Fastlane integration, code signing, artifact publishing, and automated release.

Apple Combine framework for reactive programming. Publishers, subscribers, operators, and error handling.

Instinct-based learning system with confidence scoring for mobile patterns. Automatically extracts and evolves patterns.

Pattern extraction and skill generation for mobile development sessions. Automatically learns from your coding patterns.

Core Data for iOS persistence. Data models, fetch requests, background contexts, and SwiftData migration.

Kotlin Coroutines and Flow patterns for structured concurrency, error handling, and async operations.

Deep linking patterns for mobile - Android App Links, iOS Universal Links, intent filters, URI handling, deferred deep links, and navigation integration.

Kotlin Multiplatform expect/actual patterns for platform-specific APIs. Learn to declare shared interfaces with platform implementations.

End-to-end mobile feature builder. Takes a feature from description to fully running code with E2E tests through six phases - planning, architecture review, implementation, testing, build-fix, quality gate, and verification. Supports Android, iOS, and KMP with platform auto-detection.

Feature flag patterns - LaunchDarkly, Firebase Remote Config, local feature flags, A/B testing, gradual rollouts, and KMP shared flag evaluation.

Gradle build configuration patterns for Android including Version Catalogs, convention plugins, build optimization, and multi-module setup.

Image loading patterns for mobile - Coil for Android/Compose, async image loading for iOS, caching strategies, transformations, placeholders, and error handling.

iOS testing with XCTest. Unit tests, UI tests, mocks, and test patterns for Swift/SwiftUI.

Jetpack Compose patterns for declarative UI, state management, theming, animations, and performance optimization.

Dependency Injection for KMP. Koin multiplatform setup, platform modules, and manual DI patterns.

Navigation libraries for KMP. Voyager, Decompose, and platform-specific navigation (Compose Navigation, SwiftUI).

Ktor client for Kotlin Multiplatform. Shared networking layer with platform-specific engines (OkHttp for Android, Darwin for iOS).

Repository pattern for Kotlin Multiplatform. Shared interfaces with platform-specific implementations, clean data layer architecture.

Koin dependency injection patterns for Android with modules, scopes, and ViewModel injection.

Ktor client patterns for Android networking with content negotiation, error handling, and interceptors.

Apple Liquid Glass design patterns for SwiftUI iOS 26 - glass effects, morphing, containers, interactive glass, tinting, accessibility, and cross-platform glass design.

Localization patterns for mobile - string resources, plurals, RTL support, Compose localization, KMP shared strings, and locale management.

Material 3 Expressive design patterns for Jetpack Compose - expressive theming, motion physics, shape morphing, typography emphasis, color emphasis, and all 28 expressive components.

Checkpoint workflow for mobile development safety. Save/restore Android project state at critical points.

Context compaction strategies for large Android codebases. Optimize token usage while preserving critical context.

V1 instinct-based pattern capture for mobile development. Captures patterns as code is written with immediate feedback.

V2 instinct-based observational learning. Analyzes sessions to extract reusable mobile development patterns across time.

Memory persistence for mobile development context across sessions. Maintains project structure, dependencies, architecture, and test state.

Android security patterns for secure storage, network security, input validation, and authentication.

Android testing patterns with JUnit5, Mockk, Turbine, and Compose testing for unit, integration, and UI tests.

Automated testing workflow with pass@k metrics for mobile development. Detects flaky tests and ensures code reliability.

Model-View-Intent architecture patterns for Android with unidirectional data flow, state management, and side effects.

Jetpack Compose Navigation patterns - type-safe routes, NavHost setup, argument passing, deep links, nested navigation graphs, and bottom navigation.

Offline-first architecture patterns - NetworkBoundResource, sync strategies, conflict resolution, cache invalidation, and connectivity monitoring.

Pagination patterns for mobile - Paging 3 for Android (PagingSource, RemoteMediator, LazyPagingItems), cursor-based and offset-based strategies.

Push notification patterns - FCM setup for Android, APNs for iOS, notification channels, payload handling, foreground/background behavior, and rich notifications.

Room database patterns for Android - entity definitions, DAO interfaces, Database class, migrations, TypeConverters, and Flow integration.

Shared coroutines configuration for Kotlin Multiplatform. Platform dispatchers, Flow sharing, and common scope patterns.

Shared data models for Kotlin Multiplatform using kotlinx.serialization. Cross-platform domain models with validation and serialization.

SQLDelight patterns for Kotlin Multiplatform - .sq file definitions, platform drivers, type adapters, migrations, and shared database access.

Core Swift language patterns, optionals, closures, protocols, generics, and modern Swift features.

SwiftUI UI patterns, state management, navigation, animations, and performance optimization.