Active development
The process of designing, coding, and implementing new software features or systems. It involves translating requirements into functional code, applying best practices, and ensuring that new components integrate smoothly with existing systems.
Maturity levels
|
Level |
Name |
Description |
Technology |
Example tools |
|
0 |
Non-existent |
No AI capabilities are available for development tasks. All code creation, syntax validation, and design decisions are performed manually. There is no AI functionality in tools or processes. |
||
|
1 |
One-off assist. |
AI can generate small code snippets and perform syntax correction. Suggestions can be copy/pasted from standalone tools when needed. There is no integration with IDEs or the development pipeline. |
|
|
|
2 |
Integrated assist. |
AI is embedded within IDEs, providing real-time code completions, syntax checks, and contextual suggestions. It supports boilerplate generation and basic optimizations but does not independently manage architectural or large-scale design tasks. |
|
|
|
3 |
AI-Human collaboration |
AI proposes code implementations, architectural patterns, and optimizations based on project context. It can generate entire functions or classes, adapting to existing coding standards. Humans then review, adjust, and approve AI output through iterative collaboration. |
|
|
|
4 |
Full autonomy |
AI autonomously manages the entire development cycle, including design, coding, and documentation. It interprets requirements, produces optimized solutions, runs validations, and integrates code with minimal human supervision. |
|
|
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |
Legacy code refactoring
The practice of improving the structure and quality of existing code without changing its external behavior. The goal is to increase readability, maintainability, and performance while reducing complexity and technical debt.
Maturity levels
|
Level |
Name |
Description |
Technologies |
Example tools |
|
0 |
Non-existent |
AI has no capability to assist in legacy code improvement. All restructuring, modernization, and dependency management are performed manually. Code complexity and technical debt are addressed reactively, if at all. |
||
|
1 |
One-off assist. |
AI can suggest small refactorings such as renaming variables, removing unused code, or simplifying isolated logic. Actions are triggered manually and applied without system-wide context. |
|
|
|
2 |
Integrated assist. |
AI assists consistently in detecting code smells, modernizing syntax, and improving maintainability. It can suggest changes across modules and integrate refactoring recommendations into IDEs or CI pipelines. |
|
|
|
3 |
AI-Human collaboration |
AI analyzes full codebases, identifies systemic issues, and proposes major refactoring strategies. Developers collaborate by validating impacts, resolving conflicts, and adjusting AI-generated solutions to align with business goals. |
|
|
|
4 |
Full autonomy |
AI autonomously identifies legacy code, creates a refactoring plan, executes changes across the system, and validates functionality through automated testing. It maintains compatibility and performance without human intervention. |
|
|
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |
Security assessment
The evaluation of software systems to identify vulnerabilities, weaknesses, and compliance issues. It includes analyzing code, configurations, and dependencies to ensure the application meets security standards and protects sensitive data.
Maturity levels
|
Name |
Description |
Technologies |
Example tools |
|
|
0 |
Non-existent |
AI provides no security analysis. All vulnerability checks, threat modeling, and mitigations are manual or handled by non-AI tools. |
||
|
1 |
One-off assist. |
AI can scan code for common vulnerabilities and report results on demand. These assessments are reactive and limited to specific requests or periodic checks, with results manually interpreted. |
|
|
|
2 |
Integrated assist. |
AI continuously scans for known security risks and dependency vulnerabilities as part of CI/CD pipelines. It suggests remediations but does not autonomously implement them. |
|
|
|
3 |
AI-Human collaboration |
AI prioritizes vulnerabilities, predicts potential attack vectors, and recommends mitigation strategies. Developers collaborate to verify findings, approve remediations, and refine AI-driven security improvements. |
|
|
|
4 |
Full autonomy |
AI independently monitors systems, detects vulnerabilities, applies patches, and validates security measures. It dynamically adapts to new threats and maintains compliance without human involvement. |
|
|
* A lot of vendors advertise that their AI agents are fully autonomous at discovering security breaches and fixing them. But the actual results are often “showcases” that do not really translate into real-life situations.
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |
Unit tests generation
The creation of tests that verify the correctness of individual units of code. These tests help ensure that small parts of the software behave as expected and continue to do so over time, preventing regressions during future development or system changes.
Maturity levels
|
Level |
Name |
Description |
Technologies |
Example tools |
|
0 |
Non-existent |
AI offers no capability for generating or maintaining unit tests. All test creation and updates are manual. |
||
|
1 |
One-off assist. |
AI can generate unit tests for individual functions or classes when requested. It creates simple assertions and edge cases without deep code context. |
|
|
|
2 |
Integrated assist. |
AI can consistently produce unit tests as new code is written, expanding coverage beyond simple cases. It creates meaningful inputs and expected outputs but does not adapt tests as the code evolves, unless asked to. |
|
|
|
3 |
AI-Human collaboration |
AI generates comprehensive test suites, identifies gaps in coverage, and suggests additional scenarios, including edge cases and integration points. Humans validate and refine tests based on business logic and critical paths. |
|
|
|
4 |
Full autonomy |
AI autonomously creates, updates, and maintains test suites throughout the software lifecycle. It ensures complete coverage, adapts tests as code changes, and validates results without human intervention. |
|
|
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |
Code Documentation
Code documentation relies on three distinct but complementary aspects:- Inline Documentation (like Javadoc) explains the immediate purpose, usage, parameters, and return values of specific code elements directly within the source files for developers working with the code.
- Architecture, Design & Implementation documentation details the high-level structure, technical rationale, data flows, and component interactions of the entire system. This is crucial for maintaining the system’s design integrity, supporting complex troubleshooting, and guiding the long-term evolution of the software.
- Framework/Library Tutorials & User Guides provide goal-oriented, step-by-step instructions and practical examples to help a developer successfully utilize the technology.
Maturity levels
|
Level |
Name |
Description |
Technologies |
Example tools |
|
0 |
Non-existent |
No assist. Documentation is manual, and often external (e.g., separate wiki pages) with no AI contribution. |
Manual |
|
|
1 |
One-off assist. |
Reactive Documentation. AI generates comprehensive documentation (inline comments, high-level summaries) for code blocks or files, utilizing a single chat session. The assist is reactive and requires explicit commands, with context lost once the session is closed. |
|
|
|
2 |
Integrated assist. |
Automated Inline and Basic External Docs. AI proactively suggests and updates comprehensive inline documentation (e.g., Javadoc) within the IDE/workflow. It can generate external summaries or simple API tables. |
|
|
|
3 |
AI-Human collaboration |
Co-maintained Architectural Documentation. AI drafts, validates, and maintains complex design and cross-module documentation, but the human developer retains final review, approval, and strategic direction over architectural narratives and compliance. |
|
|
|
4 |
Full autonomy |
Self-Maintaining Documentation. The AI maintains a continuous, self-correcting external knowledge base (living documentation) that mirrors the code, generating user guides, tutorials, and training materials without human intervention. |
|
|
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |
Major upgrade
A Major Upgrade is a technology update that cannot be automated by the normal build pipeline (e.g., Renovate) because it introduces a fundamental paradigm shift in the underlying framework. Such upgrades typically require manual code adjustments, changes in application architecture, or adoption of new APIs. For example, upgrading from Spring Boot 2 to Spring Boot 3 involves the platform-wide transition from Java EE to Jakarta namespaces (javax.* → jakarta.*), which affects imports, libraries, and compatibility assumptions across the entire codebase.Maturity levels
|
Level |
Name |
Description |
Technologies |
Example tools |
|
0 |
Non-existent |
No AI is used in the development workflow; all tasks (coding, reviews, testing, documentation) are performed manually. |
Manual | IDE (without AI features) |
|
1 |
One-off assist. |
Developers occasionally query standalone AI tools outside the IDE (e.g., to draft snippets, explanations, or regex), with no integration into the toolchain or codebase context. |
|
|
|
2 |
Integrated assist. |
AI is embedded in the IDE to provide contextual suggestions (autocomplete, inline docs, quick fixes) based on the current file/project, improving speed but still user‑driven. |
|
|
|
3 |
AI-Human collaboration |
AI collaborates on higher‑order tasks (design stubs, refactorings, test generation, multi‑file changes); the human remains in control of planning, review, and acceptance. |
|
|
|
4 |
Full autonomy |
AI agents plan and execute end‑to‑end tasks (issue analysis, coding, tests, PRs, validation) with minimal human intervention, operating across tools, repos, and environments under policies/guardrails. |
|
|
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |
Migration
Migration is the transformation of an application from one technology ecosystem to another when the target platform requires a new architecture, runtime, or programming model.This can involve in‑ecosystem modernization (e.g., JEE → Spring Boot, where architectural decomposition and framework replacement are needed) or cross‑ecosystem re‑platforming (e.g., COBOL → Java, where business logic must often be re‑extracted and re‑implemented).
Effective migration requires two essential preparation phases:
Functional Analysis
- Understanding current business rules, workflows, edge cases, domain objects, and user interactions.
- Often requires domain expert interviews, reading COBOL business logic, or mapping JEE services to domain processes.
- Ensures that what is migrated is functionally correct and complete.
Technical Analysis
- Inventory of components, modules, interfaces, data structures, copybooks, integrations, deployment models, and operational dependencies.
- Identifies the architectural gaps between source and target platforms (e.g., EJB container → Spring container, or COBOL file I/O → Java persistence).
Through these analyses, teams establish the migration blueprint, after which the transformation involves:
- architectural redesign,
- library and API replacement,
- code rewrite or translation,
- test regeneration,
- integration and deployment modernization.
Migration is therefore the most complex form of code evolution—beyond refactoring and version upgrades—because it alters how the system is built, run, and structured.
Maturity levels
|
Level |
Name |
Description |
Technologies |
Example tools |
|
0 |
Non-existent |
All analyses and migration activities are manual. Engineers read COBOL logic or JEE modules, map components, redesign architecture, and rewrite code without AI assistance. |
Manual | Traditional IDEs, mainframe tools |
|
1 |
One-off assist. |
Developers use external chatbots for isolated help (e.g., asking “How to convert JAX‑RS to Spring Web?”), but AI has no system context and cannot reason about the project architecture. |
|
|
|
2 |
Integrated assist. |
AI is used only as a standalone helper: explaining COBOL paragraphs, proposing Spring alternatives for JEE APIs, or drafting isolated snippets. No project context, no structural reasoning. |
|
|
|
3 |
AI-Human collaboration |
AI can analyze multiple files/services to identify business rules, map legacy structures, outline a migration architecture, generate module templates, propose Spring Boot layering, or translate COBOL programs systematically. Humans steer decisions, validate semantics, and refine the target architecture. |
|
|
|
4 |
Full autonomy |
AI agents perform end-to-end migration tasks: analyzing the legacy system (including data flows, business logic, dependencies), producing architectural proposals, rewriting code across layers, generating integration adapters, creating tests, and submitting PRs. Engineers remain supervisory reviewers. |
|
|
| AI Maturity Level: Indicates the level the technology vendors claim to have reached in deploying AI solutions that actually work in real-world applications |