QodoAI: Code with an agentic AI

In this new era of agentic AI and LLMs, I've been exploring how to use them to help me code. I've been using QodoAI, a tool that's been making waves in the development community. I've been using it for my projects, and I wanted to show you how I've been using it.

What's Qodo AI?

Think of Qodo as your coding buddy that sits right in your IDE. It's not just another AI coding tool - it focuses specifically on helping you write better, more reliable code through testing, reviewing, and generation.

Qodo (formerly known as Codium) is a quality-first generative AI coding platform that integrates directly into your development workflow. What makes it stand out is its focus on code integrity - ensuring your code isn't just written, but is robust, well-tested, and maintainable.

It's available as a VS Code extension and a JetBrains plugin.

They have about 6.9k+ stars on GitHub which is a good sign that it's a tool that people are using and finding value in.

The Three Main Tools

1. Qodo Gen - Your IDE Companion

Qodo Gen is an AI-powered coding assistant that integrates directly into your IDE (VS Code and JetBrains). It's designed to help you write, test, and review code in real-time. What sets it apart is its focus on code integrity and quality-first approach.

I'll be demoing it in VS Code, but it's also available in JetBrains.

Once you have it installed, you'll see an interface like this:

Then you can type away and it will do its best to generate the code you need. You can attach files, images, your git diffs, and more.

To get started and get chatting with Qodo Gen, you might have to sign up for a free account first. Then you have so many models to choose from, it's amazing.

I asked it to create a simple todo app in React. The experience was quite smooth, I really liked the chat UI and the fact that I could see the code changes in real-time. Although, the code it provided was without any good styling, so I had to do that part.

2. Qodo Cover - The Testing Agent

Qodo Cover is a CLI-based tool that helps you automatically generate and improve your test coverage. It's currently available as open source for Python, Java, and PHP projects.

Here's how it works:

1. Test Generation: It analyzes your code and creates new tests that actually increase coverage. For example, if you have a function without tests, it will generate meaningful test cases that cover different scenarios.

2. Coverage Validation: After generating tests, it runs them to make sure they actually work and improve coverage. If a test fails or doesn't increase coverage, it tries again with a different approach.

3. Context-Aware: The tool scans your entire codebase to understand:

   • How your code is structured
   • What existing tests you have
   • What dependencies and frameworks you're using
   • What patterns and conventions you follow

Here's a simple example of using Qodo Cover from the command line:

cover-agent \
  --source-file-path "src/app.py" \
  --test-file-path "tests/test_app.py" \
  --desired-coverage 70 \
  --max-iterations 10

You can run it in two main ways:

1. Local CLI: Run it directly on your machine while developing
2. CI Integration: Add it to your GitHub Actions or other CI pipelines to automatically generate tests for new code

When running on a Python FastAPI project, it can generate tests like:

def test_create_user_success():
    response = client.post(
        "/users/",
        json={"username": "testuser", "email": "[e-mail]"}
    )
    assert response.status_code == 201
    assert response.json()["username"] == "testuser"

The tool will also:

• Generate edge cases (like testing with invalid inputs)
• Add appropriate assertions
• Include docstrings explaining what each test does
• Follow your project's existing test patterns

One particularly useful feature is its ability to scan an entire repository and automatically identify test files that need improvement, making it practical for large codebases.

3. Qodo Merge - The PR Assistant

Qodo Merge is a code review tool that works directly in your Git repositories. It helps review pull requests and improve code quality using AI. Here's what it can do:

Main Commands

You can trigger these commands directly in your PR comments:

• /describe - Creates PR descriptions and explains code changes
• /review - Checks for bugs, issues, and security problems
• /improve - Suggests ways to make the code better
• /analyze - Shows what code changed and what needs testing
• /ask - Let's you ask questions about the code
• /similar_issues - Finds related issues
• /update_changelog - Updates your CHANGELOG.md file
• /add_docs - Creates documentation

How It Works in Practice

1. During PR Creation:

   • Automatically generates PR descriptions
   • Creates a walkthrough of your changes
   • Checks if your code matches ticket requirements

2. During Review:

   • Spots potential bugs and security issues
   • Ranks problems by how serious they are
   • Suggests specific code improvements
   • Lets reviewers chat with AI about the code

3. Integration Options:

   • Works with GitHub, GitLab, BitBucket, and Azure DevOps
   • Can run automatically or when you ask it to
   • Comes with a Chrome extension for AI chat in PRs

You can use it two ways:

1. Free Open Source Version: Available on GitHub for individual developers
2. Pro Version: For teams, with more features and support

The tool learns from your team's patterns - when you accept its suggestions, it remembers and makes better suggestions next time. It also doesn't store your code or use it to train its models, which is important for privacy.

It's available for all major git providers like GitHub, GitLab, BitBucket, and Azure DevOps.

Conclusion

Qodo is a powerful tool that can help you write better code, test it, and review it. It's a great way to get started with agentic AI in your development workflow.

Give it a try and let me know what you think!