Bring Enterprise Java modernization directly into Bob. IBM Bob Premium Package for Java extends IBM Bob with AI-assisted workflows surfaced natively in Bob chat — upgrade runtimes, migrate from WebSphere to Liberty, generate test coverage, rearchitect legacy UIs, and eliminate CVEs — all without leaving Bob.
Table of Contents
| Workflow | What it does |
|---|---|
| Java Upgrade | Upgrade to Java 11 → 17 → 21 → 25 with automated recipes + agentic fix loops |
| Liberty Modernization | Modernize from WebSphere traditional to Liberty using AMA analysis reports |
| Java Unit Testing | Auto-generate JUnit tests with JaCoCo coverage, guided by a strategy document |
| UI Modernization | Split JSF/Struts monoliths into a Java backend + React frontend |
| Java Vulnerability Remediation | Scan every Maven/Gradle dependency against CVE database |
| Spring Boot to Quarkus Migration | Modular, gate-driven skill flow with validations after every phase |
Modernizing Java applications takes more than generating code. It requires deep knowledge of the ecosystem, a structured approach to each scenario, and tooling that can handle the complexity of real enterprise codebases — multi-module projects, legacy middleware, aging test suites, and dependency sprawl.
Bob Premium Package for Java brings that expertise directly into Bob as guided, multi-step workflows. Each workflow encodes proven modernization practices into discrete, repeatable steps that run inside the editor where the code lives.
Upgrades Java applications across four LTS targets: Java 11, 17, 21, and 25.
The workflow:
- Detects your environment — reads installed JDKs, identifies your build tool (Maven or Gradle), Java EE version, and multi-module layout.
- Installs and switches Java via SDKMAN (Linux/macOS) or WinGet (Windows).
- Runs Automated recipes — selects the correct recipe and applies it against your build, tracking every modified file as a diff.
- Optional Jakarta EE migration — simultaneously upgrades
javax.*namespaces tojakarta.*using targeted EE recipes. - Builds and parses — runs your build, extracts structured errors and warnings from Maven or Gradle logs, and groups them by root cause.
- Agentic fix loop — an AI subagent works through each error category, applies fixes, and re-builds until the project compiles cleanly.
- Generates a Mermaid diagram summarizing every task, token spend, and execution time.
Supports Maven and Gradle projects, including multi-module builds.
Modernizes applications from WebSphere Application Server traditional to IBM WebSphere Liberty, guided by an IBM Application Modernization Accelerator (AMA) analysis report.
The workflow:
- Reads your AMA migration plan — unpacks the archive and the enrichment report
- Injects Liberty config — copies
server.xmland aContainerfilefrom the AMA into the correct project paths, handling multi-module layouts automatically. - Runs Liberty recipes — applies OpenRewrite Liberty replatforming recipes via Maven or Gradle.
- Agentic replatforming — an AI subagent resolves remaining compatibility issues flagged in the AMA report.
- Generates deployment guidance — produces a Liberty deployment step and a Mermaid progress diagram.
Systematically grows test coverage using an AI-driven, strategy-first approach.
The workflow:
- Detects your test setup — finds existing test files, frameworks (JUnit, TestNG), build commands, and coverage tools.
- Installs JaCoCo — if no coverage tool is configured, adds JaCoCo to the build automatically.
- Generates a strategy document — creates a project-specific unit testing strategy file that guides all subsequent generation.
- Selects candidates — lets you choose which packages, classes, or methods to target (supports git-diff-based selection for changed code only).
- Generates tests — runs targeted AI generation at the package, class, or method level, using the strategy document and existing test files as context.
- Runs tests and reports — executes the new tests and summarizes pass/fail results.
Test generation is scoped to the right granularity: a single method gets a focused prompt; a full package gets a broader one.
Separates legacy JSF or Struts monoliths into a decoupled Java backend + React frontend — with control over which parts to modernize.
The workflow:
- Analyzes the architecture — examines the project's UI framework, dependencies, and module boundaries.
- Configures targets — lets you choose the target backend framework, frontend framework, and design system.
- Backend migration — an AI subagent extracts backend logic and exposes REST APIs.
- Frontend scaffolding — sets up the React project and design system.
- Component & page generation — generates React components, the home page, and remaining pages with backend integration.
- Validates the result — runs the migrated frontend and backend to confirm correctness.
Each phase is independent — you can run backend migration, frontend setup, or both.
Scans project dependencies against the OSV.dev open-source vulnerability database.
The workflow:
- Detects dependencies — parses Maven POM files or Gradle build files to extract the full dependency list with versions.
- Queries OSV in batch — sends all dependencies to the OSV batch API in a single request, then fetches full CVE details (severity, affected versions, summary) for each hit.
- Displays results — renders a structured vulnerability list with CVSS scores directly in chat.
- Optionally fixes — launches a Bob subtask that updates or replaces vulnerable packages and verifies the build still passes.
Migrates Spring Boot applications to Quarkus using a modular, gate-driven flow that compiles after every phase.
The workflow:
- Analyzes & plans — detects existing Spring Boot footprint (starters, annotations, config) and prompts you to choose Spring Compatibility or Full Quarkus migration strategy.
- Runs gated modules — executes Spring Boot build, JPA mappings, and UI templates with their Quarkus equivalents — compiling after each phase.
- Verifies & reports — confirms a clean build, no leftover Spring dependencies, passing tests, and a live health endpoint; produces a structured migration report.
- Install IBM Bob.
- Subscribe to IBM Bob Premium Package for Java Modernization.
- Open your Java project or workspace in Bob.
- Click Start Workflow, or type any of the workflow names below in the Bob prompt to launch it directly:
Java UpgradeLiberty ReplatformingJava Unit TestingUI ModernizationJava Vulnerability RemediationSpring Boot to Quarkus
Tip: You can also launch the Spring Boot to Quarkus migration instantly by typing
/migrate-spring-to-quarkusin the prompt window.
- IBM Bob
- IBM Bob Premium Package for Java Modernization subscription
No. This add-on extends IBM Bob and requires it as a dependency.
The following upgrade paths are supported:
- Java version upgrades: You can upgrade from Java 8 to any of the modern LTS releases — Java 11, 17, 21, or 25. This covers both short incremental jumps (e.g. 8 → 11) and longer leaps across multiple versions (e.g. 8 → 25).
- Jakarta EE upgrades: You can upgrade from Jakarta EE 7 (formerly Java EE 7) to any of EE 8, 9, 10, or 11.
- Java and Jakarta EE upgrades can be run simultaneously, so you can modernise your runtime version and your API namespace in a single pass.
Only for the Java Upgrade workflow's automatic JDK install and switch steps.
Yes. Build detection, recipe execution, and log analysis all handle multi-module layouts, including correct server.xml placement for Liberty migration.
Yes. The Liberty Replatforming workflow is built around the IBM AMA analysis report. You'll be prompted to select the AMA zip at the start of the workflow.
See LICENSE.