May 26, 2026

AI coding tools for Java developers in 2026: after Amazon Q Developer, what actually works?

By AICoderScope Team · 15 min read

javajetbrainscopilotcursorkiroreviewcomparisonpricingspring-boot

Amazon Q Developer blocked new signups on May 15, 2026. Full end-of-support hits April 30, 2027. If your team has been running on Q Developer’s Java transformation pipeline — Java 8/11/17→21 upgrades, 1,000-LOC batch transforms, CodeWhisperer completions — that runway is shorter than it looks. (For a full breakdown of the Q Developer sunset timeline and migration options, see our Amazon Q Developer review and shutdown guide.)

This puts tens of thousands of Java shops in evaluation mode at the same time. The good news: the alternatives are better than Q Developer was for day-to-day coding. The bad news: none of them do automated Java version transformation out of the box. The honest answer is that each tool optimizes for a very different version of “Java developer.”

Here’s what’s actually worth paying for, based on where you sit in the Java ecosystem today.

Why Java is different from other languages for AI tools

Before getting into tool specifics, it helps to understand what makes Java a distinct target.

Java is verbose by design. A simple data class that takes four lines in Kotlin or Python expands into 30+ lines of Java: private fields, a full constructor, six getters, six setters, equals(), hashCode(), toString(). AI tools that are trained heavily on Java data see acceptance rates well above average — GitHub Copilot reports a 61% code generation rate for Java developers, versus 30–35% for JavaScript or TypeScript — because so much Java is predictable boilerplate.

But high completion acceptance doesn’t mean much if the tool doesn’t understand your Spring context. A good AI coding tool for Java needs to:

Know your Spring beans: if you’re injecting a @Service into a @Controller, the AI should complete with the right injection style, not guess at a constructor signature that doesn’t match your actual DI configuration.
Handle the type system without hallucinating generics: Java generics fail at compile time with specific, cryptic errors. An AI that generates List<Map<String, Object>> where you needed List<Map<String, List<String>>> wastes a full build cycle.
Integrate with your build tool: Maven and Gradle have very different DSL syntax. A Gradle Kotlin build script is nothing like a Maven POM, and a tool that blurs the two causes real breakage.
Talk to your LSP: completion quality in Java is dramatically better when the AI has access to the full language server diagnostics — import resolution, method signatures from your actual classpath, not just training data.

That last point is where the divide between IntelliJ-native tools and VS Code-based tools currently sits.

Tool-by-tool breakdown

JetBrains AI: the deepest IntelliJ integration, credits are the catch

JetBrains AI runs natively inside IntelliJ IDEA, Rider, and every other JetBrains IDE. The completions use JetBrains’ own Mellum model — a code completion model specifically trained on JetBrains data and focused on short, in-editor completions. Mellum is not a frontier reasoning model, but for predictive completion in established codebases it’s fast and accurate.

Pricing (verified May 26 2026):

AI Free: $0. Unlimited Mellum completions + unlimited local model support (Ollama, LM Studio). 3 cloud AI credits per 30 days for GPT/Claude/Gemini chat.
AI Pro: $10/mo individual ($20/mo business). 10 cloud AI credits/mo.
AI Ultimate: $30/mo individual ($60/mo business). 35 cloud AI credits/mo.
AI Enterprise: custom. Includes on-premises models, SSO, centralized billing.

One important note: AI Pro is bundled with the JetBrains All Products Pack at $29.90/mo (individual), making the effective AI cost near zero for All Products subscribers.

The credit system is where this gets painful for agentic work. Junie — JetBrains’ coding agent inside IntelliJ — burns credits fast: a 15-minute Junie task costs roughly $3.85 in cloud credits. At 35 credits/mo on Ultimate, you get about nine Junie sessions per month before you’re paying overages. For pure completion-and-chat workflows, credits go much further (approximately 40 in-editor generation requests per credit).

For Java developers who want IntelliJ-native agents, Junie is the only serious option. It uses a 3-tier reasoning loop and understands your IntelliJ project structure — it knows your module graph, your Spring beans, your Maven dependency tree — in a way that Cursor or Copilot running through the generic LSP cannot fully replicate. (See our JetBrains AI Assistant full review for a detailed breakdown of the credit-burn problem.)

Java-specific verdict: Best for IntelliJ users who want native integration. Use AI Free for completions (it’s unlimited via Mellum), and add AI Pro ($10/mo) only if you need regular chat with frontier models. Pay for Ultimate only if you’re doing Junie-assisted refactors where IntelliJ context matters.

GitHub Copilot: best IntelliJ plugin, strong for GitHub-centric teams

GitHub Copilot has the most complete IntelliJ plugin of any external AI tool. Since September 2025, it supports inline code review inside JetBrains IDEs — meaning you can request a Copilot code review on your local changes before opening a PR, directly from within IntelliJ. That’s a workflow most Java teams building on GitHub will recognize as genuinely useful. For a detailed breakdown of the June 2026 billing change and what it means for heavy users, see our GitHub Copilot agent mode deep dive.

Pricing (verified May 26 2026):

Free: $0. 2,000 completions/mo, 50 agent/chat requests.
Pro: $10/mo. 300 premium requests/mo, Copilot cloud agent, unlimited chat with GPT-5 mini.
Pro+: $39/mo. All models including Claude Opus 4.7, 5× premium request allocation.
Business: $19/user/mo. SSO, IP indemnity, audit logs, 1,900 AI credits/mo.
Enterprise: $39/user/mo. Includes GitHub Enterprise Cloud, custom fine-tuning, expanded context.

Note: GitHub Copilot Pro+ upgrades are currently paused as GitHub rolls out its updated credit-billing system launching June 1, 2026.

For Java developers, the IntelliJ plugin delivers code completions that draw on the language server’s context — your project’s actual classpath, not just training data. At a 61% code generation acceptance rate for Java (across all Copilot users globally), it pays for itself almost immediately on Spring boilerplate alone.

The Copilot cloud agent (Pro+) handles async tasks in GitHub Actions — useful for generating tests, fixing lint failures, or refactoring across files — but it’s GitHub-only and doesn’t run inside IntelliJ. If your workflow is: write code in IntelliJ → open PR on GitHub → let AI review and fix comments, Copilot Pro ($10/mo) is excellent value.

Java-specific verdict: The default choice for Java developers who primarily use IntelliJ and GitHub. $10/mo Pro is a genuine no-brainer; upgrade to Business ($19) if your team needs IP indemnity or audit logs.

Cursor Pro: best agents, but you’re leaving IntelliJ

Cursor is a VS Code fork. If you’re a Java developer who lives in IntelliJ IDEA, you need to understand what you’re giving up before switching.

IntelliJ Ultimate’s Spring support — bean navigation, endpoint discovery, configuration file assistance, native Gradle/Maven tooling, the debugger — has no equivalent in VS Code. Cursor’s Java experience via the Extension Pack for Java (Red Hat) is functional for typical projects but meaningfully worse for large Spring Boot applications with complex module graphs.

Cursor is actively fixing this. In October 2025 they announced a dedicated partnership with Red Hat (the maintainers of the VS Code Java Language Server) to invest in LSP performance. Early improvements: 10% faster project imports and debugger scan time reduced from 5+ seconds to under 200 ms in large codebases. That progress is real, but it still doesn’t match what IntelliJ’s built-in Java support delivers today.

Pricing (verified May 26 2026):

Hobby: free. 2-week Pro trial.
Pro: $20/mo. Unlimited completions + 500 fast premium requests/mo.
Pro+: $60/mo. ~$60 of model credits instead of $20.
Ultra: $200/mo. 20× Pro credit pool.
Teams: $40/user/mo.

Where Cursor wins for Java developers: agentic refactors that span dozens of files. If you’re doing large-scale Spring Boot migrations — pulling out a monolith into services, upgrading from Spring Security 5 to 6, refactoring a JPA entity model — Cursor Agent mode running Claude Sonnet 4.6 with multi-file context outperforms anything IntelliJ-native today. JetBrains AI’s Junie is close, but Cursor’s agent is more battle-tested on large refactors.

The trade-off is real: for daily Java development with IntelliJ’s debugger, bean navigation, and Spring tooling, staying in IntelliJ and adding Copilot ($10) or JetBrains AI ($10) is the better choice for most developers. Cursor Pro ($20) makes sense specifically if you’re willing to build your Java workflow around VS Code or if you’re doing heavy agentic refactors where Cursor’s agent quality justifies the IDE switch.

Java-specific verdict: Switch to Cursor only if you’re doing large agentic refactors and can tolerate the IntelliJ tooling gap. Not the right default for Java developers.

Kiro: the official Q Developer migration path, with a big caveat

AWS’s official answer to the Q Developer shutdown is Kiro. It supports Java, Python, TypeScript, Go, Rust, C#, Kotlin, Scala, and more. (Full feature and pricing breakdown in our AWS Kiro IDE review.) Its spec-driven workflow (requirements.md → design.md → tasks.md) is genuinely useful for large Java feature work — defining a new API contract before generating implementation tends to produce better structured code than prompting ad-hoc.

Pricing (verified May 26 2026):

Free: 50 credits/mo.
Pro: $20/mo. 1,000 credits.
Pro+: $40/mo. 2,000 credits.
Power: $200/mo. 10,000 credits.

The critical caveat: Kiro is a VS Code fork with no IntelliJ plugin today. Amazon has confirmed a JetBrains integration is coming but has given no date. For enterprise Java teams on IntelliJ — which describes most large-scale Java shops — this is a real blocker.

The workaround AWS suggests: use Kiro CLI alongside IntelliJ. The Kiro CLI connects via the Agent Client Protocol and provides chat/generation capabilities from the terminal without requiring you to leave IntelliJ. It’s functional but not the seamless in-editor experience that Copilot or JetBrains AI provide.

For AWS-native Java teams specifically: Kiro’s Java version transformation (8/11/17→21) and AWS SDK tooling are meaningful. The agentic hooks — automated test runs on file save, doc generation on commit — are genuinely useful in a Java CI/CD pipeline. But the IntelliJ gap means Kiro is a complement, not a replacement, until the JetBrains plugin ships.

Java-specific verdict: Right for AWS-native Java teams doing greenfield work in Kiro IDE. Not yet viable as a daily driver for IntelliJ users. Add Copilot ($10) or JetBrains AI ($10) as your in-IDE bridge while waiting for the JetBrains plugin.

Continue.dev: don’t rely on the IntelliJ plugin

Continue.dev is worth mentioning specifically because many Java developers discovered it as a free Copilot alternative inside IntelliJ. (For a full Continue.dev review covering the CLI and VS Code extension, see our Continue.dev 2026 review.) The short warning: as of February 2026, the Continue.dev IntelliJ plugin is community-maintained. The Continue team has explicitly recommended using the Continue CLI instead, and active development has shifted there.

This doesn’t mean the IntelliJ plugin stops working tomorrow, but it means bugs won’t be fixed on any predictable timeline and major IntelliJ updates (2026.x) may break it without a timely patch.

For Java developers who want a free BYOK option in IntelliJ today, Continue.dev’s plugin is usable but fragile. A better path is GitHub Copilot Free (2,000 completions/mo) or JetBrains AI Free (unlimited Mellum completions), both of which are officially maintained.

Comparison table

Tool	Best IDE for Java	Monthly cost (individual)	Java completions	Agents in IntelliJ	Spring/Maven context	IP indemnity
JetBrains AI Free	IntelliJ ✅	$0	Unlimited (Mellum)	Junie (3 credits)	Deep ✅	No
JetBrains AI Pro	IntelliJ ✅	$10	Unlimited (Mellum)	Junie (10 credits)	Deep ✅	No
JetBrains AI Ultimate	IntelliJ ✅	$30	Unlimited (Mellum)	Junie (35 credits)	Deep ✅	No
GitHub Copilot Pro	IntelliJ ✅ VS Code ✅	$10	Unlimited	Cloud agent only	Good	No
GitHub Copilot Business	IntelliJ ✅ VS Code ✅	$19/user	Unlimited	Cloud agent only	Good	✅
Cursor Pro	VS Code only ❌	$20	Unlimited	In-IDE agents ✅	Limited	No
Kiro Pro	VS Code fork, no IntelliJ ❌	$20	1,000 credits	In-IDE agents ✅	AWS/Java ✅	No
Continue.dev	IntelliJ ⚠️ community	$0 (BYOK)	BYOK	No	No	No

The Q Developer replacement stack

What specifically is lost when Q Developer shuts down, and what fills those gaps?

Java version transformation (8/11/17→21 batch upgrades): Q Developer Pro included automated batch transformation up to 4,000 LOC. No direct replacement in any tool at the same price point. Kiro’s transformation capabilities are closest but don’t have the same batch-file pipeline. For teams running large-scale Java upgrades, the realistic path is manual + Cursor Agent or a commercial migration service.

In-IDE completions: Any of the tools above replace or exceed Q Developer’s CodeWhisperer-based completions. This is the easiest gap to fill.

Security scanning: Q Developer’s security scan for Java/Python/JS/TS/C#/CloudFormation/Terraform is being replaced by Amazon Inspector and AWS native security services, not by the coding tools above. If you were using Q Developer for security scanning specifically, that’s a separate evaluation from AI coding tools.

AWS Console integration: The AWS Console Q Developer chat is not sunsetting and continues to work. Only the IDE plugins and Pro subscriptions are being deprecated.

Frequently Asked Questions

Does Cursor work well with IntelliJ IDEA? Cursor does not support IntelliJ IDEA — it’s a VS Code fork that runs alongside JetBrains IDEs only via MCP or external CLI tools. If you want Cursor’s agentic capabilities inside IntelliJ, there is no supported integration today. Your IntelliJ-native options are JetBrains AI and GitHub Copilot.

What happens to Amazon Q Developer’s Java transformation pipeline after April 2027? The automated Java version transformation (8/11/17→21 upgrades) provided by Q Developer Pro is not replicated in Kiro at the same price or batch scale today. Kiro supports Java and can assist with upgrade work agentic-ally, but it doesn’t offer the same 4,000-LOC transformation task as a structured product feature. Plan for manual-plus-agent-assisted migration if you depended on this.

Is JetBrains AI Free actually unlimited for completions? Yes — JetBrains AI Free provides unlimited completions via the Mellum model (JetBrains’ own code completion model), plus unlimited local model support via Ollama or LM Studio. The 3 cloud AI credits per 30 days only apply to cloud-hosted frontier models (GPT, Claude, Gemini) for chat requests. For completion-only workflows, AI Free is genuinely unlimited.

Should Java developers switch from IntelliJ to Cursor or VS Code for AI features? Not by default. IntelliJ IDEA Ultimate’s Java tooling — Spring bean navigation, Maven/Gradle integration, the debugger, refactoring engine — remains meaningfully ahead of what VS Code extensions provide. Unless you’re doing the kind of large-scale multi-file agentic refactors where Cursor’s agent quality justifies the tooling trade-off, staying in IntelliJ with Copilot or JetBrains AI is the better choice for most Java developers in 2026.

When will Kiro have a JetBrains plugin? Amazon has confirmed a JetBrains IDE integration is in development but has not given a release date. As of May 26, 2026, the Kiro JetBrains plugin is not available. In the meantime, Kiro CLI can be used alongside IntelliJ via the terminal.

Honest take

Solo Java developer on IntelliJ: Start with JetBrains AI Free (unlimited Mellum completions, zero cost). Add GitHub Copilot Free ($0) for its 2,000 monthly completions and code review capability. If you want frontier model chat regularly, upgrade Copilot to Pro ($10/mo) before spending on JetBrains AI credits. Total: $0–$10/mo.

Enterprise Java teams on IntelliJ building Spring Boot applications: GitHub Copilot Business ($19/user/mo) is the default — IP indemnity, audit logs, code review in IntelliJ, and strong Java generation at 61% acceptance. Add JetBrains AI Pro ($10/user/mo) for Junie sessions when you need deep IntelliJ-context agents. Total: $29/user/mo.

Java developers doing large-scale refactors: Cursor Pro ($20/mo) alongside IntelliJ (not replacing it). Use Cursor for the agentic refactor work, IntelliJ for daily development, debugging, and Spring tooling. Run Cursor Agent mode from a separate VS Code window pointing at the same repo. Awkward, but it gets you the best of both tools.

AWS/Java shops migrating from Q Developer: Kiro Pro ($20/mo) for new VS Code-based development and any Kiro IDE workflows. Add GitHub Copilot Pro ($10) or JetBrains AI Free for your IntelliJ users in the meantime. Watch for the Kiro JetBrains plugin — once it ships, consolidating to Kiro Pro is the natural endpoint for AWS-native teams.

The one combination that doesn’t make sense: paying for both JetBrains AI Ultimate ($30) and GitHub Copilot Pro ($10). Pick one for your primary frontier-model chat workflow. They don’t meaningfully compound at that price point.

1V1 STARTER KIT · CURSOR

Skip the week of trial-and-error setting up Cursor.

12 production-tested .cursorrules templates, 3 workflow configs, the cost-control checklist. Everything I wish I had on day one.

Get it for $19 (early bird) →

Sources

Last updated May 26, 2026. Pricing and features change frequently; verify current state before purchasing.

Was this article helpful?