Qodo Gen is the former name of Qodo’s IDE plugin. It started as CodiumAI’s TestGPT-powered test generator, expanded into chat and agentic coding workflows, then became one part of Qodo’s code-integrity platform. In April 2026 Qodo announced that autocomplete and chat-based code generation would be deprecated as the company focused on review and governance. The current IDE plugin reviews committed and uncommitted changes, applies rule-backed findings, suggests fixes, identifies and runs missing tests, and offers workflows such as unit-test, cleanup, docs, fix, and review. Evaluate it as a shift-left review and testing tool, not as a general Cursor or Copilot replacement.
- Qodo Gen is now Qodo IDE. The old name remains useful for search and migration, while the platform uses IDE, Git, CLI, and Context Engine.
- Testing is the origin. CodiumAI first built behavior analysis and guided unit-test generation.
- Code generation is retiring. Qodo announced deprecation of autocomplete and chat-based code generation in 2026.
- Review remains. Local committed and uncommitted diff review, rules, fixes, and missing-test checks define the current value.
- Agents remain task-specific. Configurable workflows can use files, git, shell, CI, cloud tools, and MCP under approved permissions.
- Use a general coding agent beside it. Qodo IDE can inspect code produced by Cursor, Copilot, Claude Code, Codex, or another implementation tool.
What Qodo Gen means in 2026
Qodo Gen refers to the IDE product formerly called Codiumate. Qodo’s current documentation calls it the Qodo IDE plugin and places it inside a platform with four mapped surfaces: IDE, Git, CLI, and Context Engine. The older public names were Qodo Gen, Qodo Merge, Qodo Command, and Qodo Aware.
| Legacy name | Current platform name | Current role |
|---|---|---|
| Qodo Gen | Qodo IDE | Local review, tests, fixes, docs, cleanup, configurable workflows |
| Qodo Merge | Qodo Git | Automated pull request review, rules, context, and findings |
| Qodo Command | Qodo CLI | Configurable quality agents and automation in terminal or CI |
| Qodo Aware | Context Engine | Codebase and cross-repository intelligence for platform agents |
The current positioning matters because many “Qodo Gen review” pages describe a product snapshot from 2024 or 2025. At that time Qodo Gen competed more directly with AI coding extensions through chat, code generation, model choice, and agent mode. Qodo’s April 2026 announcement states that autocomplete and chat-based code generation are being deprecated. The IDE plugin remains for review capabilities.
From CodiumAI and TestGPT to Qodo
The company began as CodiumAI with a narrow, practical thesis: generated tests could improve code confidence. Its early models and product work used the TestGPT name. The IDE extension analyzed a selected function, described behaviors, suggested test cases, generated code in the project’s framework, ran tests, examined failures, and helped revise the suite. That testing center distinguished it from assistants focused mainly on completing implementation code.
The product widened into Codiumate and then Qodo Gen. Chat could discuss code, agent workflows could use tools, and test generation became a guided flow rather than a one-click output. The company also released PR-Agent, whose hosted lineage became Qodo Merge, and added a CLI and cross-codebase context. In September 2024, CodiumAI renamed itself Qodo to frame the suite around “quality” and “code” and a broader code-integrity mission.
Qodo Gen 1.0 in March 2025 described a semi-agentic test flow. A developer could provide example tests, select mocks and frameworks, generate test behaviors, create a first test inside the editor, run it, inspect the result, and refine the suite. MCP could supply outside context such as database information. Later agent mode and Qodo Merge integration expanded the workflow.
Qodo 2.0 in February 2026 concentrated the commercial story on code review. The platform introduced specialized review agents, shared context, and a Rule System. In April, Qodo announced the code-generation deprecation. The current Qodo IDE documentation now opens with local review rather than autocomplete.
How Qodo test generation works
The durable test workflow starts with behavior, not raw line coverage. Qodo analyzes the selected code and surrounding project, proposes behaviors and edge cases, asks for framework and mocking context where needed, generates test code in the editor, runs or helps run the tests, and uses failures to refine the result. A good outcome is a readable suite that proves requirements and fails for the intended reasons.
Select a stable unit
Choose a function, class, changed behavior, or focused diff whose contract can be stated. Large subsystems produce vague mocks and broad assertions.
Supply examples and conventions
Point the workflow at nearby tests, factories, fixtures, naming, async helpers, and assertion style. Generated tests should look native to the repository.
Review proposed behaviors
Check happy paths, boundaries, invalid inputs, state transitions, errors, side effects, and security conditions. Remove cases that test implementation trivia.
Choose mocks deliberately
Mock unstable or external boundaries. Keep pure collaborators real when doing so makes the behavior clearer. A generated mock graph can make a test pass while proving little.
Generate and run
Inspect imports, fixtures, assertions, cleanup, determinism, and test isolation. Run the exact repository command in a clean state.
Mutation-check the important assertion
Temporarily break the production behavior or assertion target and confirm the new test fails. A test that stays green is decoration.
Qodo IDE’s current built-in workflows include unit-test, and the overview says the plugin can identify and run missing tests on code changes. That supports a modern shift-left use: inspect an AI-generated diff, identify untested behavior, add focused tests, and review the resulting change before commit.
The current IDE review workflows
Qodo IDE is currently documented for Visual Studio Code, JetBrains IDEs, and Visual Studio Professional, with language-agnostic support. The plugin analyzes local git changes and applies organization rules before a pull request exists. Its built-in workflows are command-style operations with a defined objective and output.
| Workflow | Purpose | Review point |
|---|---|---|
review-uncommitted | Group and inspect all uncommitted local changes, then offer fixes | Before commit |
review-committed | Review committed branch changes and walkthrough | Before pull request |
review | Inspect Git changes, assign severity, and suggest fixes | On demand |
fix | Review selected code and prepare applicable fixes | During local correction |
unit-test | Generate unit tests for selected code | Before or after implementation |
cleanup | Remove dead code and debug residue with test validation | Before final diff |
docs | Add or update concise documentation following project style | Before review handoff |
generate best practices | Create a structured standards file from code patterns | Rule and onboarding setup |
The review-uncommitted workflow is the clearest current value. It builds a holistic view of local changes, groups files by theme, identifies correctness, style, performance, and best-practice issues, and offers fixes. Use it after deterministic checks and before the developer mentally leaves the task. Qodo Git can then perform the independent PR review under organization policy.
Agents, workflows, tools, and permissions
Qodo defines an IDE agent as a configurable task-specific operator. An agent contains instructions, optional arguments, and selected tools. Workflows are stateless command-style agents invoked by slash command. Administrators or developers can create reusable workflows and choose whether a plan step is required. Tools can include version control, files, shell, CI, cloud environments, and MCP services.
| Design choice | Safe default |
|---|---|
| Objective | One bounded review, test, cleanup, or documentation outcome |
| Input | Explicit files, diff, branch, or argument schema |
| Tools | Minimum set needed for the objective |
| Write access | Off for analysis; scoped and approval-gated for fixes |
| Shell | Require approval except for documented read-only checks |
| Network and MCP | Allow listed services with understood data flow |
| Output | Structured findings, evidence, severity, and proposed next action |
| Failure | Stop clearly with partial evidence and no hidden source change |
Built-in Qodo tools expose git branch and change information, file history, code dependencies, and other contextual services. The plugin tells the user which tools it is using and requests approval where configured. Enterprise teams can control available agentic tools through allow-list management.
Custom agents are useful for stable review rituals: check a database migration for backward compatibility, verify a service contract, inspect authorization on new routes, or generate release notes from a fixed source. They are a weak fit for vague “make this code good” prompts whose success cannot be tested.
What the 2026 code-generation deprecation changes
Qodo’s announcement says users will lose autocomplete and chat for code-generation purposes while the IDE plugin continues to support review. Existing documentation, cached pages, extension screenshots, and old plan comparisons can still show retired behavior. A team should avoid signing a new rollout based on completion quality, general coding chat, or a broad implementation agent unless Qodo gives a current written commitment.
| Capability | 2026 status to use in evaluation |
|---|---|
| Autocomplete | Deprecated or retiring |
| Chat-based general code generation | Deprecated or retiring |
| Local code review | Current documented focus |
| Unit-test workflow | Current documented workflow |
| Missing-test detection and execution | Current IDE overview claim |
| Cleanup, docs, fix, custom workflows | Current documented workflows |
| Qodo Git pull request review | Current platform center |
| Qodo CLI quality agents | Current product surface; verify plan and release status |
For a former Qodo Gen user, choose a general coding tool based on preferred surface. Cursor or GitHub Copilot fit editor-first work. Claude Code, Codex, Gemini CLI, OpenCode, or another terminal agent fit delegated repository tasks. Qodo IDE can remain as the independent local reviewer if its findings and test workflows justify the extra extension.
Plans, access, and enterprise use
Qodo’s current pricing page sells the unified review platform, so old Qodo Gen individual-plan tables can mislead. The Pro Team offer starts with pooled review credits and includes Git and IDE integrations, pre-PR review skills, rules, dashboard, analytics, and strict retention. The plan is designed for up to 30 users. Enterprise adds organization and deployment controls.
| Plan concern | Question to ask |
|---|---|
| IDE access | Which workflows and models are included for every developer? |
| Credits | Which IDE or Git actions consume credits, and at what variable rate? |
| User coverage | Who needs an account or seat for IDE use and Git review? |
| Rules and context | Which self-learning and cross-repo features require Enterprise? |
| Data | What is retained from local code, prompts, tests, rules, and tool output? |
| Deployment | Which IDE and context services run inside single-tenant or on-prem architecture? |
| Models | Which model is selected, can it change, and when is BYOK available? |
Enterprise is the natural Qodo buyer because the review platform gains value from shared standards, multi-repository context, audit, SSO, deployment, and analytics. An individual developer should judge the plugin on local review precision and test quality. If those two features are weak on the actual repository, the wider platform story does not repair the daily experience.
When Qodo IDE is a good fit
| Choose Qodo IDE when | Choose another path when |
|---|---|
| Developers want rule-backed review before commit | The main requirement is predictive code completion |
| Unit-test generation follows stable repository examples | The team needs broad autonomous feature implementation |
| Qodo Git already applies the same organization policy | Another review system already catches local and PR issues well |
| VS Code, JetBrains, or Visual Studio Professional covers the team | Required editors or headless environments sit outside support |
| A platform owner maintains rules and workflows | No one will own configuration or learned guidance |
| Enterprise deployment and governance fit procurement | A lightweight open-source test or review tool is sufficient |
The strongest combined workflow uses a different system to author the code. A coding agent implements a bounded task and runs deterministic checks. Qodo IDE reviews the local diff and adds missing tests. Qodo Git reviews the pull request under the same quality policy. A human checks intent, architecture, evidence, and rollout risk.
A practical evaluation
Pick three real changes
Use a small bug, a behavior change with edge cases, and a cross-file refactor. Preserve the human-written tests and review findings as a reference.
Run local review
Seed one logic defect, one rule violation, and one correct suspicious pattern. Measure true findings, noise, evidence, and disposition time.
Generate tests
Provide nearby examples, review proposed behaviors, choose mocks, run the suite, and mutation-check the important assertion.
Test rule scope
Create a path-specific rule with a valid exception. Confirm Qodo flags the violation only where intended.
Exercise tools safely
Run a read-only workflow, a fix workflow, and one MCP-enabled workflow. Inspect approval prompts, changed files, network boundaries, and failure output.
Compare the full loop
Record developer minutes, accepted tests, caught defects, wrong comments, changed lines, review rework, credit burn, and whether the plugin remains in daily use after two weeks.
A generated test count is a poor success measure. Prefer behaviors proved, mutations killed, defects caught, false findings avoided, and reviewer time changed. Qodo’s code-integrity thesis should be judged on integrity evidence.
Questions people ask
Qodo Gen is the former name of Qodo’s IDE plugin, previously called Codiumate under CodiumAI. The current Qodo IDE focuses on local code review, unit tests, missing-test checks, fixes, cleanup, docs, rules, and configurable workflows.
The IDE plugin remains available under the Qodo Platform, though Qodo is retiring the Qodo Gen product name and has announced deprecation of autocomplete and chat-based code generation. Current documentation calls the product Qodo IDE.
Yes. Unit-test generation remains a documented built-in workflow. The current IDE overview also says Qodo can identify and run missing tests on code changes. Generated tests still require behavior review, execution, and mutation checks.
CodiumAI renamed itself Qodo in September 2024. The company connected the new name to quality and code and unified its IDE, pull request, CLI, and context products under a code-integrity platform.
Current Qodo IDE is better evaluated as a review and testing companion. Cursor and Copilot remain general authoring products with completion and coding agents, while Qodo is deprecating its own autocomplete and general chat code generation.
Current Qodo documentation lists Visual Studio Code, JetBrains IDEs, and Visual Studio Professional. It describes support across programming languages. Verify the exact editor version and enterprise deployment path in a pilot.
Qodo Gen named the IDE plugin, now Qodo IDE. Qodo Merge named the hosted pull request review product, now Qodo Git. The unified platform also maps Qodo Command to CLI and Qodo Aware to Context Engine.
Old individual plan descriptions may be outdated. Current Qodo pricing centers on a 14-day trial, pooled Pro Team review credits, qualified open-source access, and custom Enterprise. Check the live plan for IDE workflow and credit details before rollout.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.