Kotlin plugins

Transforms Claude Code into a full-featured development platform with 270+ language-specific skills, 90+ CLI commands, and 67 specialized agents covering code generation, review, testing, debugging, deployment, security, and automation across 40+ technology stacks.

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.

Build, deploy, and maintain Expo mobile apps with native capabilities—create native modules, integrate SwiftUI/Jetpack Compose, set up API routes, handle upgrades, configure Tailwind styling, and automate CI/CD workflows for app store submissions and update monitoring.

Scan cryptographic code for timing side-channel vulnerabilities like secret-dependent branches and divisions across Go, Rust, Java, Kotlin, C#, PHP, JS/TS, Python, and Ruby. Run constant-time analysis via skills or commands to get violation reports in JSON, with filters for warnings, architecture, and functions.

Guides building MVI stores, containers, plugin pipelines, decorators, and composing stores with API signatures and callback semantics in Kotlin Multiplatform projects.

Develop performant cross-platform UIs with Jetpack Compose and Compose Multiplatform across Android, Desktop, iOS, and Web. Get expert guidance on state management, animations, navigation, Paging 3, Material 3 motion and design systems, Android TV support, design-to-code workflows, and PR code reviews.

Build Android, Flutter, and web UIs following Material Design 3 guidelines with ready-to-use components, tokens, adaptive layouts, theming, and accessibility support.

Generate complete Flutter widgets with state management, Material/Cupertino design, responsiveness, animations, and unit tests. Set up platform channels bridging Dart to native iOS Swift and Android Kotlin code, including method handlers, EventChannels, interfaces, and testing steps.

Provides expert guidance for Jetpack Compose, Kotlin, and Android development, covering animation selection, focus navigation, layout conventions, recomposition debugging, state management, side effects, UI testing, and Multiplatform architecture. Also includes a skill that automatically shepherds open pull requests by triaging reviews, fixing CI failures, and pushing autofix commits.

Accelerate React Native mobile app development by generating full screens with navigation, layouts, data fetching, and iOS/Android-specific optimizations like keyboard avoidance, plus native modules with TypeScript interfaces, Swift/Objective-C iOS code, Kotlin/Java Android implementations, tests, and documentation.

Generate complete Android Jetpack Compose screens and ViewModels in Kotlin, including Hilt dependency injection, StateFlow UI state, sealed events, Material 3 layouts, navigation, accessibility, error handling, coroutines with retry, and unit tests following UDF pattern.

Perform fast structural code searches for symbols, classes, usages, implementations, hierarchies, and dependencies in polyglot projects spanning Android/Kotlin/Java, iOS/Swift/ObjC, web TypeScript/JavaScript (React/Vue/Svelte), Rust, Ruby/Rails, C#/.NET, Python, Go, and more via ast-index CLI. Use one-command initializers to configure Claude settings, rules, and docs for your stack.

Delegate building of native iOS/Android apps in Swift/Kotlin or cross-platform React Native/Flutter apps to an AI agent that implements performant video feeds, push notifications, biometric authentication, smooth UIs, and platform-specific integrations with optimizations for memory and scrolling.

Delegate building of native iOS/Android apps with Swift/Kotlin, React Native/Flutter cross-platform features, and mobile performance optimizations like smooth video feeds, push notifications, biometrics, and platform integrations to this specialized agent.

Review and write Kotlin coroutine code with expert-level guidance on structured concurrency, safe scoping, dispatcher selection, cancellation, exception handling, Flow, Channels, and testing with virtual time, plus lifecycle-aware collection patterns for Android.

Delegate mobile app development to a specialized agent that implements native iOS/Android features with Swift/Kotlin, cross-platform React Native/Flutter UIs, push notifications, biometric auth, video feeds, and performance optimizations for smooth experiences.

Develop Android apps for Meta Wearables using the DAT SDK: set up camera streaming, display content on Ray-Ban glasses, manage session lifecycle and permissions, and test integrations with MockDeviceKit without physical hardware.

Run 100+ specialized AI commands, skills, and agents via /spartan to scaffold Kotlin Micronaut backends and Next.js apps, provision Terraform AWS infra, automate PR reviews/gates/tests/QA, manage startup pipelines from idea validation to investor pitches, with safety locks, multi-agent coordination, and deep codebase analysis.

Implement mobile app testing strategies for React Native, iOS, and Android: configure unit tests with Jest/XCTest/JUnit, automate UI interactions using Detox/Espresso/Appium, design E2E workflows, set up device farms, and debug flaky tests or platform-specific errors.

Set up push notifications for iOS, Android, React Native, and web apps using Firebase Cloud Messaging. Handle user permissions, device tokens, foreground and background messages, and notification channels across platforms.

Debug iOS, Android, and React Native mobile apps by troubleshooting crashes, memory leaks, performance bottlenecks, and network issues using Xcode Instruments, Android Profiler, LLDB, and Logcat.

Accelerate Spring Boot development with code generation for REST controllers, DTOs, MapStruct mappers, Spring Security configs, Kafka integration, and entity-to-DTO mapping. Includes structured implementation planning and Connekt-based API testing.

Search and read source code of Kotlin/Gradle dependencies to inspect API shapes and implementations without accessing .gradle files directly

Audit mobile codebases (iOS, Android, React Native, Flutter) for observability gaps, generate instrumentation plans with priorities and timelines, instrument crashes, performance metrics, network traces, user journeys, and session replays, set up symbolication, and review code changes for telemetry best practices.

Build, test, review, and automate mobile apps (Android, iOS, KMP) with platform-specific patterns, CI/CD, and architecture guidance directly in Claude Code.

Build and manage Apollo GraphQL ecosystems: develop GraphQL servers and clients across React, iOS, Kotlin, and Rust; design schemas; compose federated supergraphs; configure routers; and manage schemas via Rover CLI or the GraphOS MCP server.

Audit mobile codebases (iOS, Android, React Native, Flutter) for observability gaps, generate instrumentation plans with vendor support (Sentry, etc.), and implement crash reporting, performance metrics, network tracing, session replay, symbolication, and user journey tracking.

Delegate full mobile app development workflows to specialized AI agents that build native iOS apps with Swift/SwiftUI/UIKit, native Android apps with Kotlin, and cross-platform apps with React Native or Flutter. They implement UI/UX patterns, platform integrations (camera, ARKit, HealthKit), state management, accessibility, performance optimizations, and ensure App Store compliance.

Develop, debug, and deploy Meta Quest and Horizon OS apps with AI-assisted workflows for project scaffolding, Unity/WebXR development, performance profiling, SDK integration, and store submission.

Provides 14+ agents, 56+ skills, and 33+ commands for Claude Code to enforce TDD, run security scans, review code, manage multi-agent workflows, and continuously learn from sessions across languages like Go, Rust, Java, Kotlin, Python, TypeScript, and C++.

Build, test, and maintain custom language SDKs generated from OpenAPI specs using the oagen framework — scafffold emitters and extractors, run compatibility checks, automate smoke tests, and fix regressions in a generate-verify loop.

Write Kotlin with coroutines for structured concurrency, build type-safe DSLs, and use null safety patterns to eliminate NPEs, with LSP support for code intelligence in .kt/.kts files.

Orchestrate structured task execution with manifest-driven workflows: define deliverables and invariants via autonomous interviews, execute tasks against acceptance criteria with verification gates, and manage the full PR lifecycle including comment triage, CI fixes, and merge readiness.

Build Android apps with MVVM, Clean Architecture, Hilt DI, Jetpack Compose UIs, and Kotlin coroutines for async operations, while automatically cleaning up orphaned worktree files on Claude Code stop events.

Understand any codebase deeply with AI: generate architecture overviews, trace code flows and data paths, assess change impacts with migration plans, discover design patterns and examples, analyze dependencies for upgrades, and review git history for hotspots and risks using 6 agent skills and 28 commands.

Battle-tested Claude Code configurations (agents, skills, commands, hooks, rules) covering TDD, code review, security scanning, multi-agent orchestration, cost tracking, social media scheduling, UI testing, Django/Laravel/Spring Boot/Rust/Go/Kotlin patterns, deployment verification, and network/homelab management across 10+ months of daily use.

Automate migration of Dependency Injection frameworks in Kotlin/Android/KMP projects to Koin 4.x Compiler Plugin from Hilt, Dagger, Toothpick, Kodein, older Koin versions, including DSL upgrades and KSP-to-Compiler-Plugin shifts.

Orchestrate full-cycle development workflows in Claude Code using dynamic multi-agent teams and skills: generate plans/specs, implement/review code across Java/Kotlin/TS/Python/Rust/Go/React/Flutter, automate E2E testing/debates/conventions, manage rules/knowledge, and optimize prompts.

Implement production Decompose navigation and components in Kotlin Multiplatform projects: detect project structure across Android/iOS/Desktop/Web, generate components with state/lifecycle/back handling, configure Stack/Slot/Pages/Panels models, and integrate with Jetpack/Multiplatform Compose UI via guided skills and commands.

Review Spring Boot codebases using skill detection and parallel agents for DDD patterns, security, testing, observability, and Modulith modules. Verify upgrades to Spring Boot 4 with multi-phase analysis producing severity-categorized migration checklists and remediation steps. Implement data layers, REST APIs, and configurations via guided skills.

Enhance Claude Code with portable skills for documentation lookup, GitHub operations, dependency intelligence, UI/UX patterns, and skill crafting, plus configurable output styles for reasoning, pair programming, minimal responses, or Socratic tutoring.

Orchestrate full developer workflows: implement tasks via TDD in isolated git worktrees, safely migrate Android/Kotlin code (Views→Compose, RxJava→coroutines, Java→Kotlin, to KMP), generate/execute test plans and exploratory QA on web/mobile apps, create/manage GitHub/GitLab PRs through CI/CD monitoring, reviews, and fixes to merge-ready state.

Build and maintain .NET MAUI apps with tools for generating release notes from workload manifests, querying SDK and NuGet metadata, and creating slim native bindings for Android (Java/Kotlin) and iOS (Swift/Objective-C) using the Native Library Interop approach.

Set up bpmn-to-code plugins in Gradle or Maven Java/Kotlin projects to generate type-safe Process API constants from BPMN diagrams for Camunda 7, Zeebe, or Operation. Migrate hardcoded BPMN string literals to these constants for type-safe refactoring.

Compose AI agent teams for complex software development tasks by selecting structures like single agents, parallel subagents, or coordinated teams, choosing models (Haiku, Sonnet, Opus), and defining communication patterns. Use predefined roles including Orchestrator, Explorer, Frontend (React), Backend (Rails), iOS (Swift), Android (Kotlin), and Database.

Refactor an existing Kotlin Multiplatform project from the old composeApp single-module structure to the new shared-plus-separate-app-module layout, handling AGP 9.0 compliance, stale IDE configurations, and project restructuring.

Design cross-platform UI/UX for web, Windows, Apple, and Android, routing ambiguous requests to focused skills. Audit designs against platform heuristics, translate between native idioms, and generate W3C DTCG design tokens to Tailwind, CSS, Compose, SwiftUI, and WinUI. Map product flows and state design.

Build production-ready frontend and mobile apps with React, Next.js 14+, React Native, and Tailwind CSS v4. Use App Router patterns, state management, responsive design systems, and component scaffolding with TypeScript, tests, and accessibility built in.

Automate Flutter integrations with native iOS and Android: set up Xcode/Android projects and SDKs, architect platform channels with Dart/Swift/Kotlin boilerplate generation, troubleshoot builds, and orchestrate emulators/simulators for app deployment, hot reload, and multi-device testing.

Enforces disciplined TDD (Red-Green-Refactor) cycles with language-agnostic code quality reviews, architecture guidance, and automated agent teams that decompose features, write tests, and refactor code.

Run Android UI tests with Maestro on headless emulators, capture screenshots and logcat, and automate web testing with Playwright for smoke tests, camera/mask verification, and animated GIF creation. Also provides planning document generation and React composition patterns for complex UIs.

Integrates the Agentforce Mobile SDK into an Android app by discovering the use case, selecting the appropriate auth flow (employee OAuth/JWT, public service agent, or guest), adding Salesforce Maven repositories and SDK dependencies, and scaffolding Kotlin files for credential provider, AgentforceClient holder, logger, network, navigation, UI delegate, and a Compose chat host.

Run portable AI skill workflows for feature implementation and code review, optimized for Android, Kotlin Multiplatform (KMP), and Kotlin backend stacks.

Set up and run Dokimos evaluations for Koog AI agents in Kotlin projects. Wire agents as systems under test or LLM judges using KoogSupport utilities, ExactMatchEvaluator, LLMJudgeEvaluator, or custom Kotlin DSL for precise AI agent testing workflows.

Set up Dokimos evaluations for AI agents to validate tool calls, check correctness and task completion, detect argument hallucinations, and assess tool definition quality across any agent framework.

Delegate to a senior mobile developer for building, optimizing, securing, and deploying React Native, Flutter, native iOS (Swift/SwiftUI), and Android (Kotlin/Jetpack Compose) apps. Handle performance tuning to 60fps, offline-first sync with local DBs, security hardening, and app store compliance with automated tooling.

Generate crash triage reports from Firebase Crashlytics for iOS and Android apps: analyze fatal errors and stack traces, propose platform-specific Swift or Kotlin fixes, assign developers via Git, and output Markdown summaries. Access crash reports, issues, stability metrics, and analytics locally using Firebase CLI.

Orchestrates a full SDLC team of specialized AI agents — product managers, engineers, QA, designers, and more — that plan, execute, and review software delivery tasks from requirements through deployment and monitoring.

Set up RevenueCat from scratch for iOS, Android, React Native, and Flutter apps: create projects/apps/products/entitlements/offerings, install SDKs, audit configurations, diagnose integration issues, query subscription KPIs, and access data via MCP server.

Scan object-oriented source code in Python, Java, TypeScript, C#, C++, Kotlin, Go, or Rust for SOLID principles violations using subcommands like `solid srp`. Receive severity-rated findings pinpointing issues with file locations and actionable refactoring suggestions to enforce Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.

Automate Claude Code workflows with 200+ battle-tested agents, skills, commands, and hooks for TDD, code review, security audits, multi-agent orchestration, build fixing, documentation sync, and project management across Python, TypeScript, Rust, Go, Java, Kotlin, Swift, and C++.

Run a full development lifecycle from brainstorming and spec refinement through planning, multi-agent code review, debugging, and PR creation, with session handover support for resuming work across Claude Code sessions.

Extend Claude Code with 190+ battle-tested skills, commands, agents, and hooks for multi-language development, testing, security, automation, and documentation. Covers TypeScript, Python, Go, Rust, Kotlin, Java, C++, and more with TDD workflows, code review, CI/CD patterns, and autonomous agent orchestration.

Generate token-efficient project snapshots in TOON format that map codebase structure for fast AI comprehension, handling single projects, multi-module setups (50+ files), and monorepos. Auto-detects architecture, saves to .snapshot/, and appends non-duplicate references to CLAUDE.md.

Switch between /solo for routine tasks like REST API design and Kotlin/PostgreSQL database patterns, and /team for complex features via codebase analysis that auto-generates structured context files (PROJECT.md, PATTERNS.md, CONVENTIONS.md) for better team workflows.