Codiumate (Qodo Gen)

Analyzes code modifications in the editor and automatically generates comprehensive test suites covering normal cases, edge cases, and error conditions. The system parses the AST of changed code, identifies function signatures and control flow paths, then uses an LLM to synthesize test cases that achieve high coverage. Tests are generated in the native test framework detected in the project (Jest, pytest, etc.) and inserted directly into test files or presented for review.

Continuously monitors code as you type in the editor, identifying bugs, code smells, standard violations, and architectural issues without requiring explicit invocation. The extension sends code snippets to Qodo servers where an LLM analyzes them against configurable organization rules, security standards, and best practices. Issues are surfaced as inline annotations in the editor with severity levels and actionable feedback.

Analyzes code changes and generates human-readable explanations of what changed, why it changed, and what impact the changes have. Explanations are generated at multiple levels of detail (summary, detailed, architectural) and can be used for commit messages, pull request descriptions, or documentation. The system understands code intent and architectural context to produce meaningful explanations rather than just summarizing syntax changes.

By default, code snippets are transmitted to Qodo servers for LLM analysis. Developers can opt out of data transmission through configuration settings on the data sharing page. The extension provides transparency about what data is transmitted and allows fine-grained control over data sharing preferences. Opt-out configuration persists across sessions and applies to all analysis operations.

When code quality issues or bugs are detected, the extension provides one-click fixes that automatically refactor or patch the problematic code. The LLM generates context-aware fixes that respect the existing code style, naming conventions, and architectural patterns. Fixes are applied directly to the editor buffer and can be undone with standard undo commands.

Performs comprehensive code review by analyzing code changes against the context of the entire codebase, including multiple repositories and dependencies. The system detects breaking changes, dependency conflicts, and architecture-level issues by understanding how modified code impacts other modules, services, and teams. Reviews are prioritized and actionable, highlighting high-risk changes and suggesting mitigation strategies.

Provides a lightweight chat interface where developers can ask questions about code, architecture, or best practices. Ask Mode uses minimal tool invocation and focuses on direct LLM responses without executing code or accessing external APIs. Useful for quick clarifications, explanations, and guidance without the overhead of full-featured analysis.

Provides a comprehensive coding assistant that can access tools, execute multi-step reasoning, and perform complex code transformations. Code Mode integrates with MCP (Model Context Protocol) tools to fetch data, run commands, and orchestrate workflows. Useful for complex refactoring, architecture design, and multi-file code generation tasks.

Provides a specialized mode for high-level architectural thinking, design decisions, and system planning. Plan Mode uses extended reasoning to analyze architectural trade-offs, suggest design patterns, and evaluate system-level implications of code changes. Useful for architecture reviews, design discussions, and strategic code decisions.

Provides pre-built and custom single-task agents that automate specific development workflows. Workflows are defined in .toml format and can be shared with teams or uploaded to the Qodo platform. Built-in workflows include documentation generation, test running and fixing, and code maintenance tasks. Each workflow is a specialized agent that orchestrates multiple steps to complete a specific task.

Allows organizations to embed custom coding standards, security policies, and architectural rules directly into Codiumate's analysis pipeline. Rules are configured through organization settings and applied consistently across all code reviews, test generation, and quality analysis. Rules can enforce naming conventions, architectural patterns, security practices, and team-specific standards without requiring external linters or policy tools.

Indexes the full codebase (including multiple repositories) to build a semantic understanding of code structure, dependencies, and architectural relationships. The indexing process parses code, extracts function signatures, API contracts, and dependency relationships, then builds a queryable graph. This index enables context-aware analysis, breaking change detection, and architecture-level issue identification across the entire codebase.