idea-plugin-dev

Guides implementing FileEditorProvider, split editors, and PersistentStateComponent in Kotlin + Compose for IntelliJ plugins.

Updated Apr 13, 2026
One-click install
npx skills add https://github.com/barsia/speqa --skill idea-plugin-dev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: idea-plugin-dev
Source: https://github.com/barsia/speqa/tree/main/.agents/skills/idea-plugin-dev
Command: npx skills add https://github.com/barsia/speqa --skill idea-plugin-dev

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

IntelliJ plugin development often requires coordinating multiple SDK APIs and editor integrations; this Skill provides guidance for implementing FileEditorProvider, split editors, persistent state components, actions, and i18n wiring in Kotlin + Compose to build robust JetBrains plugins.

Core Features & Use Cases

  • Guidance on integrating FileEditorProvider and split editors (TextEditorWithPreview) to create cohesive editing experiences within the IDE
  • Patterns for implementing PersistentStateComponent settings, DynamicBundle i18n, IconProvider, ToggleAction, and ErrorReportSubmitter, plus debugging plugin.xml wiring
  • Use cases include debugging sandbox issues, wiring actions into menus, and ensuring undo/history preservation during patching or updates

Quick Start

Register plugins and implement a split editor by following the patterns shown for FileEditorProvider, TextEditorWithPreview, and sandbox debugging in Kotlin + Compose.

Frequently Asked Questions about idea-plugin-dev

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a split editor with preview in an IntelliJ plugin using Kotlin?

To implement a split editor in IntelliJ plugin development, use the TextEditorWithPreview pattern alongside FileEditorProvider. This Skill guides wiring these components in Kotlin to create cohesive editing experiences within the JetBrains IDE.

How do I persist plugin settings in IntelliJ using PersistentStateComponent?

PersistentStateComponent is the standard mechanism for persisting plugin settings in IntelliJ. This Skill provides implementation patterns for wiring PersistentStateComponent to store and retrieve configurations reliably in Kotlin plugins.

Can I build IntelliJ plugins with Kotlin and Compose for advanced editor integrations?

Yes, building IntelliJ plugins with Kotlin and Compose supports advanced editor integrations. This Skill covers implementing FileEditorProvider, split editors, and necessary infrastructure specifically for JetBrains plugin development.

How do I add internationalization to a JetBrains plugin with DynamicBundle?

DynamicBundle provides internationalization for JetBrains plugins. This Skill details how to wire DynamicBundle for i18n support, alongside patterns for implementing IconProvider, ToggleAction, and ErrorReportSubmitter in Kotlin.

Why is my IntelliJ plugin not showing actions in the menu after updating plugin.xml?

Debugging plugin.xml wiring issues requires checking sandbox configurations and action registrations. This Skill provides sandbox debugging patterns to identify why actions fail to appear in IntelliJ menus.

What is the best way to debug an IntelliJ plugin in a sandbox environment?

The best way to debug an IntelliJ plugin involves using sandbox debugging patterns to test plugin.xml wiring and editor integrations. This Skill guides setting up sandbox environments to validate Kotlin and Compose plugin behavior.