intellij-openspec — Summary

intellij-openspec is a JetBrains IDE plugin (IntelliJ IDEA 2024.2+) that provides native OpenSpec workflow orchestration without leaving the IDE. It supports four usage personas: spec browser (read-only reviewer), IDE-first developer (uses existing Copilot/Cursor/Cline tools via clipboard delivery), CLI companion (Claude Code/Gemini CLI users), and standalone API user (direct AI provider integration). The plugin features a three-tab tool window (Browse/Coverage/Console), a DAG-based artifact pipeline (proposal → design → specs → tasks), three AI delivery modes (copy for tool / open in editor tab / generate via API), inline editor inspections for OpenSpec annotation validation, gutter markers for @spec annotations, and a setup wizard. It detects 28 supported AI tools by scanning project directories. AI API keys are stored in the OS keychain via IntelliJ's PasswordSafe. The plugin is available on JetBrains Marketplace (ID: 30678-openspec).

differs_from_seeds: No seed framework is a JetBrains IDE plugin. The closest seed is kiro (a full IDE for spec-driven development), but intellij-openspec integrates into an existing IDE rather than replacing it. Unlike spek's IntelliJ plugin (which is read-only), intellij-openspec provides full workflow orchestration including propose, generate, apply, verify, and archive actions.

intellij-openspec — Overview

Origin

Published by johnnyblabs, Apache-2.0 license, v0.0.x (build version from gradle.properties). Available on JetBrains Marketplace as plugin 30678-openspec. Last commit 2026-05-02.

Philosophy

From the README: "An IDE-native client for the OpenSpec spec-driven development framework by Fission AI. Browse specs, orchestrate the propose → generate → implement → archive lifecycle, and route AI-generated artifacts through the tool of your choice — all without leaving IntelliJ."

The plugin explicitly supports four personas (Spec Browser, IDE-First Developer, CLI Companion, Standalone API User) — acknowledging that users have different existing AI tool setups and the plugin should integrate with, not replace, existing tools.

Manifesto-style statements (from feature-reference.md)

• "The plugin distinguishes placeholder/scaffold content from real content. An artifact file containing only template comments is treated as 'not done,' preventing false pipeline progression."
• "Profile-Aware Action Visibility: Workflow actions respect the active OpenSpec profile. Actions whose workflow is not enabled in the current profile appear visible but disabled with a tooltip."
• "API keys are stored securely in your operating system's keychain via IntelliJ's PasswordSafe — never saved in project files."

Target user

Four defined personas:

1. Spec Browser — reviewer/PM wanting to browse specs and track coverage
2. IDE-First Developer — using Copilot/Cursor/Windsurf/Cline inside IntelliJ
3. CLI Companion — using Claude Code/Gemini CLI terminal tools
4. Standalone API User — using a direct AI API key

intellij-openspec — Architecture

Distribution

• JetBrains Marketplace: plugin ID 30678-openspec
• Build from source: Kotlin + Gradle

Install methods

# From Marketplace (recommended)
Settings > Plugins > Marketplace > search "OpenSpec"

# From source
git clone https://github.com/johnnyblabs/intellij-openspec.git
cd intellij-openspec
./gradlew build
# Install from build/distributions/OpenSpec-*.zip

Requirements

• IntelliJ IDEA 2024.2+ (Community or Ultimate)
• Java 21 JDK (for building from source)
• OpenSpec CLI 1.3.x (optional but recommended for full experience)

Tech stack

• Language: Kotlin
• Platform: IntelliJ Platform SDK
• Build: Gradle (build.gradle.kts)
• UI: IntelliJ platform UI components
• Webview: Not JCEF-based (unlike spek's IntelliJ plugin) — uses native IntelliJ components

Directory structure

intellij-openspec/
├── src/main/kotlin/  # Kotlin source
├── build.gradle.kts
├── gradle.properties
├── settings.gradle.kts
├── docs/
│   ├── feature-reference.md
│   ├── feature-comparison-matrix.md
│   ├── getting-started-browser.md
│   ├── getting-started-copilot.md
│   ├── getting-started-cli-companion.md
│   └── getting-started-api.md
├── openspec/         # Uses itself as an OpenSpec project
└── scripts/

Multi-tool configurations discovered

The plugin scans project directories to detect 28 AI tools:

AI delivery modes

1. Copy for [Tool]: clipboard with tool-specific guidance
2. Open in Editor Tab: temporary editor tab for review
3. Generate via API: direct to AI provider (Anthropic/OpenAI/Gemini)

Security

API keys stored via IntelliJ's PasswordSafe (OS keychain) — never in project files.

intellij-openspec — Components

Tool Window (3 permanent tabs + 1 conditional)

Workflow Actions (OpenSpec menu)

DAG-based artifact pipeline

proposal → design → specs → tasks

Workflow Action Panel shows status chips: Done (green checkmark) / Ready (blue filled circle) / Blocked (gray empty circle)

Editor Inspections

Three real-time inspections as you edit (names not fetched — likely: invalid @spec annotation, missing spec file reference, etc.)

Gutter markers

@spec annotations in Java source → clickable gutter icons → navigate to referenced spec file

Profile-aware action visibility

core profile: Propose, Explore, Apply, Archive expanded/custom profile: All actions including Fast-Forward, Continue, Verify, Sync Specs, Bulk Archive

Scaffolding detection

Placeholder/scaffold content in artifact files treated as "not done" — prevents false pipeline advancement.

intellij-openspec — Uniqueness & Positioning

differs_from_seeds

No seed framework is a JetBrains IDE plugin. The closest seed is kiro (a full IDE built for spec-driven development), but kiro replaces the IDE while intellij-openspec integrates into IntelliJ IDEA. The AI delivery mode abstraction — routing the same assembled prompt to any of 28 detected AI tools or to 3 direct API providers — has no equivalent in any seed framework. Seeds assume a specific tool (Claude Code, kiro, cursor); intellij-openspec explicitly supports tool heterogeneity within a team (some members use Copilot, others use Claude Code, others use direct APIs). The four-persona design is also distinctive: it acknowledges that the same plugin must serve reviewers, IDE-native developers, CLI-focused developers, and API-direct users.

Positioning

• Category: JetBrains IDE plugin — multi-tool OpenSpec workflow orchestration
• User: IntelliJ IDEA developers who use OpenSpec and may have any AI tool as their primary assistant
• Integration: IDE-native; complements any existing AI tool via delivery mode abstraction
• Value: Full OpenSpec lifecycle in IntelliJ with AI tool routing, coverage analysis, gutter markers, profile-aware workflow

Observable failure modes

1. 28-tool detection relies on directory presence: AI tools that store config elsewhere are not detected
2. Scaffolding detection: Plugin distinguishes placeholder from real content — any edge case in template detection breaks pipeline progression
3. Java 21 build requirement: Higher barrier for contributors
4. Fast-Forward / Continue require Direct API: Teams without API keys must use the slower copy-and-paste workflow
5. Profile-based feature gating: Teams used to Fast-Forward/Continue features on one machine may lose them if profile changes
6. Windows CLI detection: Plugin auto-detects openspec.cmd from multiple paths — custom install locations may require manual path override

Cross-references

• Requires: OpenSpec framework (Fission AI)
• Similar to: spek's IntelliJ plugin (same IDE) but completely different scope (spek is read-only viewer; intellij-openspec is full workflow orchestration)
• Feature comparison matrix exists at docs/feature-comparison-matrix.md — presumably compares with VS Code alternatives