Kotlin plugins

Design and implement UI components, design systems, and accessible interfaces for mobile (iOS, Android, React Native) and web applications. Includes WCAG compliance auditing, responsive layouts, microinteractions, and cross-platform component patterns.

Build, profile, and launch cross-platform mobile applications with expert guidance spanning Flutter/Dart, React Native, and native iOS/Android — covering App Store optimization, performance tracking, state management, and production-ready architectural patterns.

Accelerate full-stack development with 66 specialized skills covering 12 languages, frontend/backend frameworks, infrastructure, DevOps, security, and testing, plus Jira/Confluence project management commands for epic planning, discovery, and retrospectives.

Scan frontend codebases for XSS vulnerabilities and implement secure coding patterns across React, Vue, Angular, and mobile apps with expert agents for both security fixes and general frontend development

Develops cross-platform mobile apps for iOS and Android using Flutter, Swift, React Native, and Expo, with guidance on App Store optimization, performance tracking, and modern architecture patterns.

Build and deploy mobile apps across iOS and Android using React Native/Expo, Flutter, and native Swift/Kotlin, with integrated CI/CD via EAS, App Store optimization, and cross-platform API development.

Provides Kotlin language intelligence including diagnostics, go-to-definition, find references, hover information, symbols, and call hierarchy for .kt and .kts files

Fuzz C/C++, Rust, Python, and Ruby code with coverage-guided fuzzers (libFuzzer, AFL++, cargo-fuzz), detect memory errors via sanitizers, and set up continuous fuzzing with OSS-Fuzz. Includes static analysis with Semgrep and CodeQL, timing side-channel detection, and cryptographic test vectors.

Reviews disabled tests, ensures Neovim annotations are documented, and improves test readability for the IdeaVim project. Use for periodic test maintenance.

Provides expert-level assistance for Jetpack Compose and Compose Multiplatform development across Android, Desktop, iOS, and Web — covering state management, animations, navigation, performance optimization, Material 3 design-to-code, and automated PR review for Compose projects.

Guide Kotlin Multiplatform developers in using FlowMVI to design MVI architecture with stores, containers, plugin pipelines, decorators, and contracts for state, intents, and actions.

Implement Google's Material Design 3 UI system including tokens, 30+ components, adaptive layout, theming, and accessibility for Jetpack Compose (primary), Flutter, and limited web.

Guides Kotlin and Android developers through Jetpack Compose UI patterns, performance optimization, state management, testing, and coroutine best practices, plus automates PR review and issue resolution workflows.

Create Flutter widgets with state management and Material/Cupertino design, and bridge Dart with native iOS (Swift) and Android (Kotlin) code via platform channels including EventChannel support.

Generate production-ready Android ViewModels and Jetpack Compose screens with unidirectional data flow, sealed UI state, Hilt dependency injection, and Material 3 theming — scaffolds loading, error, and empty state handling alongside StateFlow-coroutine data loading.

Bootstraps Android app development with Kotlin, Jetpack Compose, and MVVM architecture, while also providing a comprehensive multi-stack development environment with AI agent orchestration, TDD enforcement, code review, database guidance, and project management across mobile, web, and backend projects.

Manage encrypted key-value persistence in Kotlin Multiplatform projects using KSafe, handling tokens, passwords, and secrets across Android, iOS, macOS, JVM Desktop, and web with platform-native secure storage.

Fast structural code search across polyglot projects using ast-index CLI — find symbols, classes, usages, implementations, hierarchies, and dependencies in Android/Kotlin/Java, iOS/Swift/ObjC, TypeScript/JavaScript, Rust, Ruby, C#, Python, Go, and more.

Detects Kotlin coroutine concurrency bugs — GlobalScope leaks, runBlocking in suspend, missing Flow catch, wrong dispatchers, cancellation mistakes — and guides on making async code testable.

Guides mobile app testing strategies including unit tests, UI automation, and E2E flows, with support for setup, device farms, and flaky tests across iOS and Android.

Debug mobile apps (iOS, Android, React Native) with platform-specific tools like Xcode Instruments, Android Profiler, LLDB, and Logcat to diagnose and fix crashes, memory leaks, performance issues, and network problems.

Implement push notifications for iOS, Android, and web using Firebase Cloud Messaging. Handles permissions, token management, background/foreground messages, and notification channel setup.

Add motion, micro-interactions, generative art, and creative effects to web, Android (Compose), and Apple (SwiftUI) interfaces. Includes animation patterns for React (Framer Motion, GSAP, Three.js/R3F), Compose, and SwiftUI, plus design system rules, accessibility checks, and performance audits.

Develop Android apps for Meta Ray-Ban Display glasses using the DAT SDK — handle setup, camera streaming, display UI, permissions, session lifecycle, device simulation for testing, and diagnostics.

Spring Boot development accelerator: code generation for controllers, DTOs, security, and Kafka; testing with coverage; debugging; project exploration; and Spring Data best practices.

Guides Android and Kotlin Multiplatform development across the full stack — architecture, Compose UI, coroutines, networking, storage, DI, testing, and build optimization.

Develop, debug, and deploy Android applications using Jetpack Compose, Kotlin Coroutines, and Clean Architecture. Automate Google Play releases, manage in-app purchases, monitor crash reports, and optimize build performance with Gradle. Includes testing patterns, UI audits, and Play Console integration.

Develop and manage Apollo GraphQL applications across the full stack: build servers with Apollo Server, client apps with Apollo Client (React, iOS, Kotlin), federated schemas, router configuration, and schema design. Includes MCP integration with Apollo GraphOS and LSP for GraphQL files.

An engineering discipline layer that provides structured workflows for full-stack development, infrastructure management, startup validation, and team coordination — with commands for building features, debugging, deploying, reviewing code, managing Terraform/AWS, running QA, and creating investor materials.

Write Kotlin code with advanced coroutine patterns, type-safe DSLs, and null safety, while getting automatic formatting and testing on save and LSP-powered code intelligence.

Audit, plan, and instrument mobile app observability across iOS, Android, React Native, and Flutter — covering crash reporting, performance monitoring, session replay, and distributed tracing with actionable gap analysis and vendor-agnostic rollout strategies.

A comprehensive skill agent system that transforms Claude Code into a multi-agent development platform with auto-extracted skills and hooks

Design Apple-platform apps (iOS, macOS, tvOS, visionOS, watchOS) and Android UIs following official HIG/Material Design 3 guidelines, plus build accessible web interfaces with WCAG 2.2 patterns

Search and read source code of Gradle-managed Kotlin/Java dependencies directly from the CLI, inspecting API shapes and implementations without needing to open .gradle files or navigate external sources.

Build mobile apps for Android, iOS, and Kotlin Multiplatform with AI-assisted coding patterns, automated build/test commands, and expert agents for architecture, code review, performance, and security.

Build native iOS apps with Swift/SwiftUI/UIKit and cross-platform mobile apps for iOS and Android using React Native or Flutter, handling platform integration, App Store review, and UX optimization

Create iOS-style liquid glass and frosted glass UI components in Compose Multiplatform, applying glassmorphism, blur, vibrancy, and lens effects using the backdrop library.

Instrument mobile apps with crash reporting, performance monitoring, session replay, and distributed tracing across iOS, Android, React Native, and Flutter. Scan codebases for observability gaps, generate prioritized instrumentation plans, and audit telemetry quality against best practices.

Audits mobile app projects against Apple App Store and Google Play review policies before submission, supporting native, Flutter, React Native, Expo, Kotlin Multiplatform, .NET MAUI, Cordova, Ionic, and Unity projects.

Develop and validate React Native projects with skills covering UI component construction, native module bridging (Swift/Kotlin), navigation patterns (React Navigation), performance optimization, platform-specific code handling, and Flexbox styling.

Build and debug Meta Quest VR/MR applications with tools for project scaffolding, Unity and WebXR development, Spatial SDK and Platform SDK integration, performance analysis, device debugging, and store submission checks.

Streamline Playwright end-to-end testing with best practices for fixtures, page objects, and multi-browser project configuration. Includes automatic Kotlin code formatting and testing on file changes.

Design, build, audit, and deploy mobile apps across iOS, Android, React Native, and Flutter. Includes app architecture, performance audits, feature specs, tech stack reconnaissance, Fastlane release pipelines, and platform-specific UI guidelines.

Provides Android development patterns and validation with Gradle build hooks, including MVVM architecture, Jetpack Compose UI, and Kotlin coroutines for async operations.

Write and maintain Cucumber BDD tests using Gherkin syntax, with best practices for feature files, scenario outlines, and step definitions in JavaScript/TypeScript, Java, and Ruby. Also automatically formats and tests Kotlin code during editing.

Build a complete design system end-to-end: author tokens, styles, icons, and components in Figma, then sync tokens to framework-specific code via Style Dictionary, generate Storybook stories with Chromatic visual regression, and stand up a monorepo with CI.

Develop iOS/macOS apps with advanced Objective-C patterns for ARC memory management, GCD concurrency, and protocol/category design; includes automated Kotlin code formatting and testing.

Write Elixir applications with expert-level support for OTP concurrency, Ecto database patterns, and pattern matching, backed by an LSP server for diagnostics and navigation.

Develop Gleam applications on the BEAM VM with OTP concurrency patterns, safe Erlang interop, and expressive type system. Includes a language server for code intelligence and hooks for Kotlin formatting/testing.

Build, test, and maintain Claude Code plugins with a specialized agent for architecture, validation, and marketplace integration, plus automated hooks that format and test Kotlin code during development.

Analyze and enforce code quality standards in Elixir projects using Credo, with tools to explain issues, configure rules, and create custom checks for consistency, readability, and refactoring.

Curated collection of 140+ skills, commands, agents, and hooks for Claude Code that enforces TDD, code review, security scanning, multi-model orchestration, session management, and project-specific coding standards across TypeScript, Python, Go, Java, Kotlin, Swift, and C++ stacks.

Develop Erlang applications with language server support and guided patterns for concurrency, distribution, and OTP behaviors. Also automatically formats and tests Kotlin code on edit and write events.

Provides a comprehensive collection of Claude Code agents, skills, commands, hooks, and rules for AI-assisted development across multiple stacks, including code review, testing, automation, security auditing, and project management workflows.

Provides idiomatic coding guidance for C#/.NET, Go, Java/Kotlin, Python, Rust, TypeScript, and web (HTML/CSS/HTMX), plus an agent that applies changes and runs build/test/lint gates.

Recreate UI designs in Sketch from reference URLs, screenshots, or source code, and generate production-ready UI code (React, Tailwind, SwiftUI, Kotlin) from Sketch designs with 1:1 visual fidelity

Understand any codebase through AI-powered analysis of architecture, code flows, dependencies, git history, and design patterns. Generates actionable structured reports for onboarding, impact assessment, refactoring, and upgrade planning.

Scaffold Android projects with Jetpack Compose and Material Design 3, set up CI/CD with GitHub Actions, manage Play Store releases with signing and staged rollouts, and get expert guidance on app architecture, performance, Gradle optimization, and Play policy compliance.

Orchestrates a multi-agent AI harness for React Native and Expo development, enabling autonomous feature implementation, code review, performance profiling, visual debugging, and version migration through coordinated agents and commands.

Executes complex tasks through manifest-driven workflows: plans work via structured interviews, defines deliverables with verification gates, runs automated checks against invariants and acceptance criteria, audits code quality across PRs, and tends GitHub PRs to merge-readiness with CI and comment handling.

Provides Kotlin 2.x language expertise for code review, coroutine/Flow debugging, null-safety enforcement, and type-system guidance using the K2 compiler. Not for Android framework.

Design cross-platform mobile architecture and interaction UX across iOS and Android, including platform selection, performance optimization, CI/CD, thumb-zone ergonomics, touch targets, gestures, navigation patterns, onboarding, permissions, and accessibility.

Standardizes project setup with AGENTS.md 1.1, then provides a modular skill pack for code review, security audits, JetBrains IDE plugin development, SQL-to-TypeScript conversion, Linear task automation, React+Vite SPA guidance, release management, AI prompt engineering, and structured documentation generation.

Generate Kotlin/Spring Boot backends and Compose Multiplatform mobile apps with AI agents that create feature slices, enforce layered architecture, run OWASP security audits, write isolated tests, and automate DevOps pipelines.

Get code intelligence for Kotlin and Java files in Claude Code — diagnostics, go-to-definition, find references, and hover information for .kt, .kts, and .java files via the ktlsp language server.

Teach Claude Code to use the Xmake build system: scaffold projects, configure targets, manage C/C++ packages, cross-compile for Android/iOS/WASM, optimize build performance, and author custom plugins or build rules

Enforce modern Java 17+ idioms, detect and configure Maven or Gradle build tooling, and apply JUnit 5 / Mockito / AssertJ / Testcontainers testing patterns across any JVM project.

Automates migration of Kotlin/Android/KMP projects from Hilt, Dagger, Toothpick, Kodein, or legacy Koin DSL to the Koin 4.x Compiler Plugin with Safe DSL or Annotations.

Orchestrate multi-agent AI teams for complex software development tasks, choosing between single-agent, parallel subagents, and coordinated team structures. Includes predefined roles like Orchestrator, Explorer, and stack-specific agents (React, Rails, iOS, Android, Database) with model selection and communication pattern guidance.

Build and maintain .NET MAUI apps with tools for generating release notes from workload data, discovering SDK and NuGet metadata, and creating Android (Java/Kotlin) and iOS (Swift/ObjC) native bindings using slim interop approaches.

Migrates Kotlin Multiplatform / Compose Multiplatform projects from the old single-module `composeApp` structure to the new default layout with separate `shared`, `androidApp`, `desktopApp`, and `webApp` modules, including AGP 9.0 compliance.

Manage Maven and Gradle dependency lifecycles: search artifacts, check versions, resolve conflicts, audit vulnerabilities and licenses, inspect transitive graphs, and maintain version catalogs — all from Claude Code.

Generate, fix, and configure Decompose components and navigation models (Stack, Slot, Pages, Panels) in Kotlin Multiplatform projects, with Compose UI integration and platform setup for Android, iOS, Desktop, and Web.

Guides Domain-Driven Design with Spring Boot 4, including bounded contexts, aggregates, REST APIs, Spring Data, Modulith modules, security, testing, observability, and upgrade verification from 3.x to 4.x.

Enforces disciplined TDD (Red-Green-Refactor) cycles with clean code reviews, architecture guidance, and domain-driven design. Includes autonomous agents for code review, API design, and UX specification, plus prompt-injection defense for GitHub workflows.

Build, optimize, and deploy high-quality mobile apps for React Native, Flutter, iOS (Swift/SwiftUI), and Android (Kotlin/Jetpack Compose) with expert guidance on performance optimization, security hardening, offline-first architecture, and App Store/Play Store deployment.

Manage Flutter platform integration across Android and iOS, including native configuration (Gradle, Xcode), platform channel communication between Dart and native code, and orchestration of multiple simulators/emulators for testing, building, and deployment.

Develop, test, and release Android apps with Kotlin/Java — handles project setup, Gradle/AGP configuration, mixed-language modules, linting, test triage, and release readiness checks (signing, ProGuard, app bundles, CI routing).

Automate mobile app testing across Android emulators and iOS simulators, drive web UI tests with Playwright, enforce accessibility, and audit code architecture and security — all as structured Claude Code skills and agents.

Guides Expo SDK 56+ inline native module changes across Swift/Kotlin, TypeScript interface generation, and prebuild validation for tasks involving requireNativeModule or expo-type-information.

Migrates hardcoded BPMN string literals in Java/Kotlin projects to type-safe generated constants, with setup automation for Gradle or Maven build systems targeting Camunda 7, Zeebe, or Operaton.

Build and ship production mobile apps end-to-end: architecture, offline support, UI, state management, auth, push notifications, CI/CD, performance profiling, testing, and App Store/Google Play releases across React Native, Flutter, and native iOS/Android.

Guides through integrating the Agentforce Mobile SDK into an Android app: discovers use cases, selects auth flow (OAuth/JWT, public service agent, or guest), adds Salesforce Maven repos and dependencies, and scaffolds Kotlin files for credential provider, client holder, logging, networking, navigation, UI delegate, and Compose chat host.

Generate Spring Boot services and Kotlin validation rules from BPMN files, enforce BPMN style guides with automated validation, and migrate bpmn-to-code API usage across versions.

Evaluate AI agents by validating tool calls, correctness, task completion, argument hallucinations, and tool definition quality using Dokimos, a framework-agnostic evaluation system.

Configure Dokimos evaluation harnesses for Koog AI agents using Kotlin DSL, supporting exact-match and LLM-as-judge evaluators for agent testing.

Scan frontend codebases for XSS vulnerabilities and implement secure coding patterns across React, Vue, Angular, and mobile apps (iOS/Android) with expert guidance on sanitization, WebView security, and client-side security.

Set up RevenueCat projects, integrate in-app purchases and subscriptions for iOS and Android apps, query subscription KPIs, and diagnose configuration issues.

Build cross-platform iOS and Android apps with SwiftUI, transpiling to Kotlin or compiling natively via Skip Fuse. Scaffold projects, manage icons and localization, integrate optional frameworks, and deploy to both app stores.

Govern the full SDLC within Claude Code — validate ideas against market data, plan features through a multi-agent scrum team, enforce quality gates on every file write, audit test suites for mock violations, and fix bugs with automated root-cause analysis and tiered validation.

Guide adding or reviewing analytics event tracking in Android apps with a typed tracker abstraction, ViewModel-owned tracking, consent-gated PII-safe events, and testing with a fake tracker.

Orchestrates a full SDLC team of specialized AI agents—frontend/backend engineers, Kotlin/Spring Boot devs, data analysts, UX researchers, QA, product/project managers, document writers, code reviewers, SEO managers, and SREs—that plan, dispatch, and synthesize work across planning, implementation, review, testing, and delivery phases.

Orchestrate the full software development lifecycle from specification to deployment with AI agents that plan features, write tests, review code, fix builds, audit security, and automate releases across multiple languages and frameworks.

Analyze object-oriented source code for violations of the five SOLID principles (SRP, OCP, LSP, ISP, DIP) across multiple languages. Get severity-rated findings with file locations and refactoring suggestions via subcommands like `solid srp`.

Orchestrates the full development lifecycle from brainstorming and spec validation through multi-agent code review, debugging, planning, implementation, and PR creation with session handover support.

Accelerates Android Kotlin development with Jetpack Compose by generating complete feature modules, performing code reviews, diagnosing build errors, analyzing Compose performance, and guiding TDD cycles — all with built-in security scanning and documentation generation.