01
Understand IntelliJ project structure
Inspect Gradle or Maven modules, SDK and language settings, source roots, generated code, project files, run configurations, and repository conventions.
IntelliJ IDEA projects
CategoryDeveloper Tools
IntelliJ Codex Skills
IntelliJ Codex Skills help Codex work effectively in repositories opened with IntelliJ IDEA, including Java and Kotlin code, Gradle or Maven builds, run configurations, inspections, tests, refactoring plans, and IntelliJ Platform plugin projects. Download the skills for changes that respect both the codebase and the IDE project environment.
IntelliJ IDEAJava and KotlinGradle and MavenIDE plugins
01
02
03
04
05
06
07
08
09
02
03
04
05
06
07
08
09
task: complete intellij idea projects task
inspect:
- requirements and context
- existing standards
- failure and edge cases
verify: outputs + checks + handoffWhy a specialist workflow matters
A code change can pass a narrow test and still break project import, generated sources, run configurations, inspections, or IDE plugin compatibility.
IntelliJ projects combine source code with build models, SDKs, language levels, modules, generated files, formatting, inspections, and local IDE state.
These skills help Codex treat the build files and repository conventions as the source of truth, preserve shareable project settings, and avoid depending on private local configuration.
What the downloadable skills can do
What IntelliJ Codex Skills can help accomplish
02
Develop Java and Kotlin code
Navigate symbols and tests, implement focused changes, refactor safely, handle dependencies, and follow framework and language patterns.
03
Work with IDE quality signals
Address compiler errors, tests, formatting, static analysis, inspections, nullability, deprecations, and project-specific checks.
04
Build IntelliJ Platform plugins
Create actions, services, tool windows, inspections, intentions, settings, plugin metadata, tests, compatibility ranges, and sandbox runs.
A repeatable working process
How the intellij idea projects workflow moves from request to verified result
The steps keep context, implementation, and verification visible so the result can be reviewed and repeated.
workflow.statusREADY
Context → Plan → Work → Verify
01
Inspect the build and IDE context
Read settings and build files, modules, SDK requirements, source sets, generated directories, shared project files, tests, and run targets.
02
Trace symbols before editing
Follow usages, inheritance, interfaces, dependency injection, configuration, resources, serialization, and affected tests.
03
Implement through project conventions
Make the smallest coherent change, preserve formatting and generated-file rules, update dependencies carefully, and avoid committing personal IDE state.
04
Verify outside and inside the IDE model
Run the repository's build and tests, check import or sync implications, review inspections, and exercise relevant run configurations.
Useful across real projects
Where IntelliJ Codex Skills fit
The workflow adjusts to the project, audience, tools, and risk while preserving the same quality standard.
Java and Kotlin applications
Develop backend, desktop, library, and command-line code with Maven or Gradle project structures.
Framework projects
Work with Spring, Jakarta, Android-related modules, persistence, build plugins, code generation, and framework configuration.
IntelliJ Platform plugins
Build plugin features, extension points, UI, inspections, tests, packaging, signing preparation, and compatibility checks.
Large multi-module builds
Navigate shared conventions, composite builds, dependency graphs, generated sources, test fixtures, and module boundaries.
Common requests
Tasks these skills can handle
Start with one defined outcome and provide the source material, constraints, and checks that matter.
01Understand an IntelliJ project
02Implement a Java or Kotlin change
03Fix Gradle or Maven import issues
04Add or repair tests
05Review shared .idea files
06Create a run configuration
07Build an IntelliJ plugin
08Resolve inspections or compatibility problems
Who benefits most
Who Is This For?
These skills are designed for people who need dependable intellij idea projects work with a visible process.
Java and Kotlin developers
Make repository-aware changes with suitable build, test, and IDE verification.
IntelliJ plugin developers
Create and maintain plugins against declared platform versions and extension APIs.
Teams using JetBrains IDEs
Standardize shareable project configuration without committing machine-specific state.
Developers joining large projects
Understand modules, builds, source roots, frameworks, run targets, and project conventions faster.
Good to know:
The skills can edit repository and shareable IntelliJ project files. Live IDE clicks, private settings, licensed features, plugin installation, and local UI state require the user's IntelliJ environment or an approved integration.
Set up the workflow
Installation Guide
Install the complete skill folder and add the project-specific context before beginning.
Download and extract the IntelliJ skills
Keep SKILL.md with project, Java, Kotlin, build, inspection, and plugin-development guidance.
Choose project scope
Install with the repository so the skill can follow its modules, build system, SDK requirements, and shared conventions.
Document the IntelliJ environment
State IntelliJ edition and version, JDK, Kotlin version, Gradle or Maven version, plugins, frameworks, and supported platforms.
List build and IDE checks
Provide sync, compile, test, formatting, inspection, run, plugin sandbox, and packaging commands or procedures.
Before you download
Frequently Asked Questions
Practical answers about capabilities, limits, setup, and review.
Do the skills control IntelliJ IDEA directly?+
They primarily work with repository files and commands. Live IDE interaction requires a supported connection or user action.
Can they work with Java and Kotlin?+
Yes. They follow the languages, frameworks, build system, and versions declared by the project.
Will they edit .idea files?+
Only shareable project settings that the repository intentionally tracks. Machine-specific workspace and private state should remain uncommitted.
Can they create IntelliJ plugins?+
Yes. They can work with plugin metadata, Gradle configuration, extension points, actions, services, UI, inspections, tests, and sandbox runs.
Do they replace IntelliJ inspections?+
No. They use repository checks and can address supplied inspection results, but the configured IDE remains an important verification surface.
Make the work repeatable
Give Codex an IntelliJ-aware workflow that respects the build model, project structure, shareable settings, and IDE quality signals.
Clear context. Purposeful work. Relevant checks. A result others can understand.