Skip to main content
Beta Qodo Agentic Toolbox gives your coding agent capabilities for understanding your codebase, applying project rules, reviewing changes, and resolving review findings. You can use these capabilities independently or combine them into a workflow that fits how you work. The workflows below are examples you can use as a starting point and adapt to your development process.

​
Build a feature

Use the toolbox to guide your agent from exploring the codebase through reviewing the final changes.

​
1. Explore the codebase

Before making changes, ask your agent to understand the relevant parts of the codebase. Use Codebase Wisdom to explore:
  • How the existing implementation works
  • Related components and dependencies
  • Existing patterns and conventions
  • Potential edge cases
  • The impact of changing shared interfaces
For example:
Explore how the checkout flow currently works. Identify the relevant components, dependencies, existing patterns, and potential edge cases. Don’t make any changes yet.

​
2. Plan the implementation

Ask your agent to propose an implementation plan before writing code. The plan should consider:
  • The relevant code and existing patterns
  • Project rules and available skills
  • Potential edge cases and regression risks
  • Tests that should be added or updated
Review the plan and adjust it before asking the agent to implement it.

​
3. Implement using project guidance

Ask your agent to check the rules and skills available for the task and apply any that are relevant. For example:
Before implementing, check the available project rules and skills. Use any that are relevant to this feature.
Keep the implementation focused on the approved plan and existing project conventions.

​
4. Review local changes

After implementation, use Review to review the local changes before creating a pull request. You can run the review as a loop:
Review the current changes. Focus on correctness, error handling, and regression risks. Fix the issues you find, then run the review again.
You can limit the number of review iterations if you want to control how long the agent spends reviewing. You can also give the agent specific areas to focus on based on issues your team has encountered before:
Review these changes with particular attention to retry behavior. Similar changes in this area have caused duplicate requests in the past.

​
5. Create the pull request

Once the local changes meet your requirements, create the pull request using your normal workflow.

​
6. Review and resolve findings

After Qodo reviews the pull request, use Review Resolver to have your agent evaluate and resolve Qodo’s findings before merging. Give the agent guidance about which findings to prioritize:
Review Qodo’s findings. Prioritize correctness and security issues. For each finding, determine whether it is valid before making a change. Ignore findings that are intentional based on the existing architecture.

​
Debug an issue

You can use a similar workflow when investigating and fixing a bug.

​
1. Investigate the issue

Ask your agent to trace the relevant code path and identify the likely root cause. For example:
Investigate this bug. Trace the relevant code path, identify the likely root cause, and look for similar implementations or previous fixes. Don’t make changes yet.
Use Codebase Wisdom to help your agent understand the codebase and its history.

​
2. Plan the fix

Ask the agent to explain the root cause and propose a focused fix. Have it consider:
  • Why the current behavior occurs
  • Which code needs to change
  • Potential edge cases
  • Regression risks
  • Tests needed to verify the fix
Review the proposed fix before asking the agent to implement it.

​
3. Implement and review

Ask the agent to implement the fix using the relevant project rules and skills. Then use Review to review the local changes. Ask the agent to focus on regression risks and related code paths. For example:
Review this bug fix with particular attention to regression risks and other code paths that could be affected. Fix valid issues and run the review again.
Repeat the review until the changes meet your requirements, or set a maximum number of review iterations.

​
4. Verify the fix

Run the relevant tests and verify that the original problem is resolved. Ask the agent to confirm that the fix addresses the root cause rather than only the observed symptom.

​
5. Resolve pull request findings

After creating the pull request, use Review Resolver to review Qodo’s findings before merging. Give the agent additional context about the bug when deciding which findings require changes.

​
Customize your workflow

The workflows above are starting points, not required processes. Adapt them to your development process and the capabilities available in your coding agent. You can:
  • Add steps that are specific to your team’s development process.
  • Give your agent specific review areas based on previous issues.
  • Set a maximum number of review iterations.
  • Change which Qodo capabilities your agent uses at each stage.
  • Add your preferred workflow instructions to your agent’s AGENTS.md or equivalent configuration.
For example, you might create a workflow that always asks your agent to:
  1. Explore the relevant code before making changes.
  2. Propose a plan and identify edge cases.
  3. Check applicable rules and skills.
  4. Implement the change.
  5. Run a local review and resolve valid findings.
  6. Create the pull request.
  7. Use Review Resolver to evaluate Qodo’s findings before merging.
The goal is to give your agent a repeatable process that combines its existing capabilities with Qodo’s code understanding, rules, review, and finding-resolution capabilities.

​
Additional resources

  • Agentic Toolbox: Learn about the Agentic Toolbox, its tools, supported interfaces, and installation.
  • Codebase Wisdom: Help your agent understand your codebase and its history.
  • Review: Review local changes before creating a pull request.
  • Review Resolver: Evaluate and resolve Qodo review findings.