Imagine you’re using one AI tool for everything - designing, planning, coding, reviewing, etc.
After a while, you start to see some pitfalls in the LLMs output.
While many LLMs are doing okay for general-purpose tasks, they tend to fall short when it comes to highly specialized tasks.
That’s why it is important to use different types of AI agents, each optimized for a different task.
For example, let’s say you have a UI problem. You would ask for help from the Front-End guy, not the Back-End guy, even though the Back-End guy has some knowledge of the front-end too.
We should apply the same logic and approach to using LLMs as well.
Use the right agent for the right task so we can craft better software.
In the previous article, we covered the systematic AI code review workflow: Plan, Generate, Validate.
Now, let’s map the right tools to each phase:
- Plan → use Advisors (think through decisions)
- Generate → use Generators (write code fast)
- Validate → use Reviewers (catch issues automatically)
Each phase needs a different type of AI agent. Let’s understand what makes each one specialized and what traps to avoid when using.
The Three Types of AI Agents
Each AI agent is trained and optimized for specific tasks.
Using a generator for security review is like using a hammer to tighten a screw.
It’s technically possible, but we would use the wrong tool for the job.
Here is the breakdown:
- Advisors (Claude, ChatGPT)
- Purpose: understanding and decision making
- Optimized for: explaining concepts, evaluating trade-offs, designing, researching, refactoring strategy
- Blind to: your specific codebase, real-time feedback, automated integration
- Generators (Cursor, Copilot)
- Purpose: fast code implementation
- Optimized for: speed, autocomplete, pattern matching
- Blind to: security vulnerabilities, architectural implications, edge cases
- Reviewers (CodeRabbit and similar)
- Purpose: quality assurance and bug detection
- Optimized for: security, bugs, performance, consistency
- Blind to: design decisions, why code exists, future requirements
If you’re wondering when to use each, use these questions to navigate your judgment:
- Need to make a design decision? → use Advisor
- Need to write code fast? → use Generator
- Need to validate code quality? → use Reviewer
Your role is to select the tool, knowing which agent to use and when. You have to validate, reason, and do problem-solving.
Now, let’s dig deeper into each AI agent.
Note: Some IDEs, like Cursor, have different modes built in, like Agent, Plan, Debug, Ask, so you could use one IDE, switch the mode, and have a different type of AI agent. However, you still have to know how to use each of those tools.
The Advisor: When Decisions Matter
Advisors don’t write your code or review it automatically.
They help you think through problems, break down complex tasks into an executable plan, understand trade-offs, and make better decisions before you start implementing a specific approach.
Advisors excel at explaining the “why” behind code, not just what it does, but the reasoning and trade-offs that led to that implementation.
✅ With Advisors, you should prefer:
- Using before making major architectural decisions
- Understanding existing and/or unfamiliar code
- Exploring different approaches and strategies and their trade-offs
- Providing context about your project, current choices, and structure
- Learning new patterns and concepts
⛔ With Advisors, you should avoid:
- Writing code (generators are faster)
- Using them for bug detection (reviewers are better)
- Expecting it to know your codebase or internal team’s dynamics
- Following advice blindly without understanding
So,
Advisors help you make better decisions.
Use them before you start coding, not after.
The Generator: When Speed Matters
The Generators excel at writing code quickly.
They’re autocomplete on steroids, trained on millions of code examples to predict what you’re trying to write.
**✅**With Generators, you should prefer:
- Using for daily coding, boilerplate, CRUD operations, etc
- Scaffolding tests
- Writing type definitions and interfaces
- Writing code to follow existing patterns and conventions
- Iterating on suggestions and do not always accept the first try
⛔ With Generators, you should avoid:
- Trusting it for security-critical code without review
- Assuming it validates business logic
- Assuming it writes proper type definitions of your domain models
- Using it to make architectural decisions
- Skipping review because “AI wrote it”
So,
Generators are for speed. Always validate the output with a review and your reasoning.
Use them after you have a concrete plan in mind.
The Reviewer: When Quality Matters
Reviewers are specialized for finding issues in existing code.
An example of a Reviewer is CodeRabbit.
They don’t generate. They analyze, detect patterns and conventions, and flag problems.
**✅**With Reviewers like CodeRabbit, you should prefer:
- Using on every PR before merging
- Addressing security and bug findings immediately
- Using suggestions as learning opportunities (you could ask Advisors to help)
- Configuring rules and guidelines for your specific tech stack and codebase
⛔ With Reviewers like CodeRabbit, you should avoid:
- Skipping review because the code “looks fine”
- Dismissing warnings or applying suggestions without understanding them
- Using it to write new code (wrong tool)
- Expecting it to validate business logic
So,
Reviewers help us catch things which generators miss.
They act as our QA and Security guy.
Use them while or after you generate code. Then you fix and repeat.
Now that we understand each agent’s specialty.
Here is how to use them together effectively:
- Making a decision? → Advisor (understand trade-offs first, make a plan)
- Writing code? → Generator (fast implementation)
- Code written? → Reviewer (catch issues automatically)
- Issues found? → Generator (quick fixes) → Reviewer (validate)
And remember:
⚠️ Your role is to select the tool and always validate and understand the output!
When Agents Disagree
Sometimes, different agents might suggest conflicting approaches.
Here is how I resolve them:
- For architecture, I weigh the Advisor’s opinion carefully, but also consider the current context, business needs, and constraints.
- For implementation details, I follow the generated code from the Generator because it knows the codebase best and the already established patterns.
- For security issues, I trust the Reviewer’s suggestions (like CodeRabbit) because security is non-negotiable.
In the end, the final decision is yours because you know all the specific domain and business context, needs, and constraints.
AI shouldn’t be your excuse for making wrong and unjustified decisions.
You are the Software Engineer who navigates and drives the AI, not the other way around.
You’re the final decision maker!
📌 TL;DR
- Using one AI tool for everything means missing what other specialized tools catch.
- Prefer to use a different AI agent, each optimized for different tasks
- We have generally three types of AI agents: advisors (Claude/ChatGPT), generators (Cursor/Copilot), and reviewers (CodeRabbit).
- Match the tool to the tasks, advisors for decisions, generators for speed, reviewers for safety.
So try out these three agent types in your daily coding workflow and let me know how you found them.
I promise this way of working will improve your code.