Atlassian Forge Developer - Intelligent IDE Plugin
A WebStorm/JetBrains plugin delivering intelligent autocompletion, real-time validation, and integrated documentation for Atlassian Forge development - 83 OAuth scopes, 71 event types, 155+ project templates, all modeled in Kotlin.
Kotlin Lines
9,120
main + tests compiled
Total Files
112
112 files across all categories
OAuth Scopes
83
Fully modeled with descriptions
Forge Templates
155+
Cataloged by product & UI type
Presentation
Project overview and context
Atlassian Forge Developer is a plugin for WebStorm (and compatible JetBrains IDEs) that provides intelligent support for Atlassian Forge application development. It delivers contextual autocompletion, advanced syntax highlighting, real-time validation, and automatic quick fixes for `manifest.yml` files - the central configuration file of every Forge application.
The plugin targets developers building cloud applications for the Atlassian ecosystem (Jira, Confluence, Bitbucket, Compass, Jira Service Management) via the Forge platform. Before this plugin, developers edited their manifest.yml files without any IDE assistance: no suggestions, no validation, no contextual documentation. Every error in this file was only revealed at deployment time, causing costly debugging cycles.
The plugin is exclusively designed for Forge applications and does not support Atlassian Connect applications (which use `atlassian-connect.json`).
The plugin only activates its features when it detects a genuine Forge project via dual criteria: the `manifest.yml` contains an `app.id` starting with `ari:cloud:ecosystem::` AND a `package.json` in the same directory contains at least one `@forge/` dependency. This ensures the plugin never interferes with other YAML files.
Objectives, Context, Stakes & Risks
Strategic context and identified challenges
The Atlassian Forge Developer plugin was created to fill a critical gap: the complete absence of IDE tooling for the proprietary manifest.yml format used by Atlassian Forge.
Developer Experience
First-class
IDE-native support for Forge development in WebStorm
Error Reduction
Pre-deploy
Real-time validation catches errors before deployment
Product Coverage
5 products
Jira, Confluence, Bitbucket, Compass, JSM + Rovo
Documentation
Integrated
Atlassian documentation searchable directly from the IDE
Templates
155+
Official Forge templates accessible via project wizard
Context
The project builds on the official JetBrains template for IntelliJ Platform plugin development. The Forge manifest schema is complex and proprietary: it covers hundreds of properties across modules for 5 Atlassian products, 83 OAuth 2.0 scopes, 71 event types, and 155+ project templates. This entire schema had to be modeled in Kotlin to power autocompletion and validation.
Stakes
Developer productivity: every minute saved on Forge configuration impacts thousands of developers in the Atlassian ecosystem. Code quality: pre-deployment error detection avoids costly debugging cycles on the cloud platform. Strategic positioning: being the first (and potentially only) dedicated Forge IDE plugin provides significant competitive advantage on the JetBrains Marketplace.
Atlassian schema dependency
The Forge schema evolves regularly; the plugin must track updates or risk becoming obsolete
IDE compatibility
Supporting WebStorm versions 2024.2 to 2025.2 (builds 242-252) requires rigorous compatibility testing
PSI complexity
Manipulating the IntelliJ Platform syntax tree (PSI) is technically demanding and prone to subtle regressions
Market adoption
Pre-release version (0.1.0) may limit initial adoption on the Marketplace
The Steps - What I Did
Implementation journey from initialization to stabilization
- Forked the official JetBrains intellij-platform-plugin-template
- Configured project for WebStorm (platformType = WS)
- Set up app.addly.atlassian package structure
- Configured dependencies: YAML plugin, kotlinx-serialization, SnakeYAML, Gson, Coroutines
- Set up 5 GitHub Actions CI/CD workflows
- Modeled the complete Forge schema in ManifestSchema.kt (669 lines)
- Cataloged 83 OAuth 2.0 scopes across all Atlassian products
- Cataloged 71 event types for Forge triggers
- Built contextual autocompletion (ManifestCompletionContributor, 370 lines)
- Built real-time validation (ManifestValidator, 620 lines)
- Built IDE inspections with quick fixes (ManifestInspection, 341 lines)
- Built advanced syntax highlighting (ManifestSyntaxHighlighter, 250 lines)
- Implemented intelligent Forge project detection (dual ARI + @forge/ criteria)
- Built integrated Atlassian documentation search panel via Algolia API
- Added contextual hover documentation (tooltips on manifest properties)
- Built visual environment variable manager (multi-env, encryption, sync)
- Integrated Forge CLI execution (deploy, tunnel, install, lint)
- Built Forge project wizard covering 155+ official templates by product and UI type
- Created development scripts: hot-reload, log monitoring, error analysis
- 10 test files covering: completion, validation (5 files), highlighting, detection, setup, generation
- Test data: valid and erroneous manifests, package.json, XML rename files
- IDE Run Configurations: Run Plugin, Run Tests, Run Verifications
- Qodana static analysis with JDK 21
- Kover code coverage reporting
Actors & Interactions
Collaboration model and stakeholder ecosystem
This plugin was developed as a solo project under the Addly brand (https://addly.app), a company dedicated to building developer productivity tools. As sole developer, I handled the full product lifecycle: architecture design, implementation, testing, CI/CD, documentation, and Marketplace preparation.
Development was assisted by Claude Code for code generation and pair-programming sessions. The development workflow combined deep Atlassian Forge domain expertise (mine) with AI-accelerated implementation - a model where the human provides vision, architecture, and domain knowledge while AI assists with code execution.
| Source | Lines | % of Total | Files |
|---|---|---|---|
| JetBrains Template (unchanged) | 1,636 | 10.8% | 20 |
| Adapted from template | 652 | 4.3% | 6 |
| Original (Dev + Claude Code) | 12,921 | 84.9% | 86 |
| TOTAL | 15,209 | 100% | 112 |
External Dependencies
Atlassian provided the Forge platform, documentation, and Algolia search API. JetBrains provided the IntelliJ Platform SDK, plugin template, and Marketplace distribution infrastructure. The Forge developer community represents the target user base.
Results
Deliverables, metrics, and personal growth
For the Product
Plugin Extensions
12
Completion, annotator, inspection, highlighter, tool windows, etc.
CI/CD Workflows
5
Build, release, UI tests, template cleanup, template verify
Icons & Visuals
19
7 SVG icons + 10 PNG readme + 2 SVG readme
Utility Scripts
5
1 bash + 3 JS + 1 JSON configuration
For the Company (Addly)
The plugin is a publishable product on the JetBrains Marketplace with a fully automated publication pipeline (signing + deployment). It provides complete coverage of the Forge schema across all 5 Atlassian Cloud products. To date, no direct competitor exists on the JetBrains Marketplace for specific Atlassian Forge support.
For Me - What I Learned
This project deepened my expertise in several technical and strategic areas:
- Kotlin advanced patterns - coroutines, serialization, DSL, IntelliJ Platform conventions
- IntelliJ Platform SDK mastery - PSI manipulation, extension points, inspections, quick fixes, tool windows, completion contributors, syntax highlighters
- IDE plugin architecture - lifecycle management, extension points, actions, listeners, file type handling
- Developer Experience (DevEx) as a discipline - understanding that an IDE tool saving 5 minutes daily per developer justifies itself rapidly at scale
- AI-assisted development workflows - using Claude Code with detailed specifications (CLAUDE.md) for accelerated implementation while maintaining architectural control
- Domain modeling precision - the schema files (ManifestSchema, Scopes, EventTypes) represent the core value; the more precise the model, the more useful the plugin
What Came After
Post-development state and future trajectory
Immediate State
The plugin reached version 0.1.0 with all planned core features implemented. The JetBrains Marketplace publication pipeline is fully automated via GitHub Actions: a GitHub Release triggers signing, packaging, and deployment. The CI/CD includes 5 workflows covering build, test, static analysis (Qodana), compatibility verification, and automated release.
Planned Evolution
The immediate roadmap includes: committing the initial codebase to git (currently unversioned), improving test coverage beyond the current ~14.5% ratio, internationalizing all UI messages (currently 8 i18n properties), and creating automated schema update scripts to track Atlassian Forge changes programmatically rather than manually.
Current State & Series Context
The plugin is in active development as part of a broader series of JetBrains IDE plugins built under the Addly brand. This particular plugin was chosen for presentation because it best demonstrates the technical depth and product completeness achievable with the IntelliJ Platform SDK. Other plugins in the series follow similar patterns of deep domain modeling combined with comprehensive IDE integration.
Critical Reflection
Honest retrospective on successes and improvement areas
- Exhaustive functional coverage: autocompletion, validation, highlighting, quick fixes, integrated documentation, variable management, and project creation
- Clean, modular architecture organized by feature (completion, validation, highlighting, search, forge), each module with clear responsibility
- Rigorous schema modeling: 83 scopes, 71 events, 155+ templates cataloged with descriptions
- Intelligent dual-criteria project detection avoids false positives
- Mature CI/CD: 5 GitHub Actions workflows covering build, test, Qodana analysis, compatibility verification, and signed publication
- Development tooling: dev-webstorm.sh with watch, monitoring, debug options + log analyzer
- No git commits: the repository is initialized but no commit has been made - no version history, no rollback capability, no change traceability
- Pre-release version (0.1.0): may limit initial Marketplace adoption
- Limited test coverage: ~14.5% test-to-code ratio (1,157 lines tests / 7,963 lines main)
- Minimal i18n: only 8 message properties - many strings likely hardcoded in Kotlin source
- French-language documentation for scripts: may limit international contributions if open-sourced
Lasting Lessons
- Developer Experience (DevEx) is a high-impact domain - a tool that saves 5 minutes per day per developer quickly justifies itself at scale across the Atlassian ecosystem
- The IntelliJ Platform is powerful but demanding - PSI manipulation, extension points, and API conventions require significant learning investment but enable deeply integrated tooling
- Domain modeling is the core value - the schema files (ManifestSchema, Scopes, EventTypes) represent the plugin's fundamental worth; the more precise and complete the model, the more useful the plugin becomes
- AI as a development accelerator - the CLAUDE.md specifications + Claude Code workflow demonstrates how AI can assist complex project development, from implementation to debugging, while the human maintains vision and architectural control
Architecture & Technical Diagrams
Related journey
Professional experience linked to this achievement
Skills applied
Technical and soft skills applied
Image gallery
Project screenshots and visuals
