Reviewing Code Generated by AI

With the increasing use of AI agents in software development, it’s becoming more common for parts of the codebase to be written with the help of automated tools. These agents can help accelerate repetitive tasks or suggest solutions, but it’s still essential to carefully review everything that is generated.

AI-generated code tends to follow generic patterns, often without considering the project’s specific context or technical decision history. For this reason, several particular points should be evaluated during the review:

Code organization

A very common issue in AI-generated code is the lack of structural organization. Since the agent doesn’t have full knowledge of the project’s architecture, it tends to group everything into a single file: controllers, services, models, and utility functions end up mixed.

This approach might work for isolated examples, but in real-world projects with multiple contributors, it compromises clarity and maintainability.

It’s essential to verify that the implemented code is correctly positioned. Should the function be in another module? Does the logic belong to the layer where it was added? Are multiple responsibilities being handled in a single file? These questions help determine if the code respects separation of concerns and aligns with the project’s architecture.

Good organization facilitates testing, reuse, and future evolution. When everything is grouped without a clear structure, the risk of unnecessary coupling increases, and understanding the system becomes more difficult.

That’s why, when reviewing AI-generated code, ensuring everything is in the right place is just as important as verifying whether it works.

Reimplementation of existing functions

Another frequent issue with AI-generated code is the reimplementation of existing functions within the project. This often happens when those utilities aren’t well-documented or don’t follow clear naming conventions. Since the agent can’t see the full codebase, it ends up recreating logic from scratch even when a function with the same purpose already exists elsewhere.

During review, it’s essential to question whether the new function really needs to be created. Does it already exist elsewhere in the system? Could this have been solved with a simple import? Are there behavioral differences between the new code and the existing code?

Rewriting something already available and tested not only increases code duplication but also makes maintenance harder, introduces inconsistencies, and may even lead to subtle bugs. Whenever possible, it’s best to reuse what already exists, keeping logic centralized and consistent. The less duplication, the lower the risk and the greater the predictability of the system.

Read more: How to Integrate AI Into an App

Invalid imports

A recurring behavior in AI-generated code is the attempt to import functions, classes, or modules that don’t actually exist in the project. Often, the agent assumes that a component is part of the system based on common naming patterns and writes the import as if the code were available. The problem is that these elements might not exist, might be named differently, or reside in a different location with a different structure.

During review, it’s important to validate all import statements. Do the modules actually exist in the project? Are the function and class names accurate? Is the import aligned with the project’s current organization?

These types of errors might go unnoticed initially, especially in files that haven’t been executed or tested yet, but they can cause significant problems later on when the code reaches production or requires maintenance.

Ensuring that imports are accurate and contextually appropriate is a basic, yet essential, step for avoiding future issues and maintaining the system’s integrity.

Read more: Beyond “Vibe Coding”: Engineering with AI and Cursor

Misalignment with project standards

Even when AI-generated code is functional, it may be misaligned with the project’s standards and conventions. It’s common to see variable names that don’t follow team conventions, missing type annotations in strongly typed projects, or structural inconsistencies such as business logic embedded in controllers or utility functions mixed with domain logic.

This kind of misalignment affects readability, hinders maintenance, and contributes to a general feeling of disorganization. Sometimes, the AI even replicates poor practices already present in the codebase, reinforcing problems instead of correcting them.

That’s why the review process should verify whether function names, file names, and variable naming follow established conventions. It’s also important to ensure that the architecture is being respected, that the code is placed in the correct layer, and with the right level of abstraction.

Consistency is one of the key pillars for safely evolving a system. Even if the code works, misaligned implementations are harder to understand and more prone to bugs in future updates. Beyond verifying functionality, reviewers should ensure that the new code “fits” naturally within the existing system.

Practical tips to avoid these issues

To reduce the most common problems found in AI-generated code, developers can adopt a few practical habits that improve reliability and alignment with the project’s architecture:

• Provide clear context up front: Whenever possible, share file paths, architecture descriptions, naming conventions, and relevant code excerpts before asking the AI to generate something. The more context the AI has, the less likely it is to misplace logic or create invalid imports.
• Request small, focused pieces of code: AI performs best when working on well-scoped tasks, helper functions, small components, unit tests, or specific parts of a larger workflow. Smaller and isolated outputs are easier to review and less likely to violate architectural boundaries.
• Cross-check with existing project utilities: Before accepting a new function or module, compare it with what already exists in the codebase. This helps prevent duplicated logic, unnecessary rewrites, and subtle inconsistencies.
• Validate all imports immediately: A quick pass through import statements avoids several downstream issues. Confirm that modules exist, names match, and paths reflect actual project organization.
• Enforce project standards and conventions: Treat consistency as non-negotiable. Ensure variable names, file structures, type annotations, and architectural rules align with the rest of the system. AI-generated code should feel like it naturally belongs in the project—not like an external addition.
• Always perform a human review: Even when AI-generated code works, it must still be reviewed with the same rigor applied to manually written code. Clarity, testability, separation of concerns, and maintainability remain the responsibility of the developer.

Read more: AI & Machine Learning Glossary: Key Terms for Modern Businesses

Final thoughts on using AI in development

In existing projects, using AI to assist in code development can be highly productive as long as it’s done carefully. The best way to leverage these tools is to delegate small, well-defined tasks, such as helper methods, data transformations, unit tests, or business logic blocks.

It’s up to the developer to think about architecture and how the new functionality fits within the system. Having a clear reference of the project’s architecture is essential to ensure that the generated code is placed correctly, respecting existing responsibilities and standards.

When it’s necessary to use AI for developing something larger, like a full feature or a broader refactor, the ideal approach is to provide real code examples from the project and give explicit instructions about where each part should go.

This includes specifying file names and paths, describing each layer’s role, and pasting relevant snippets whenever possible. Even so, this approach requires caution, as there’s always a risk that some part of the generated code won’t fully align with the project’s structure.

One important point to remember is that when you use AI to write code, you become the first reviewer of that implementation. Before opening a pull request, it’s crucial to thoroughly review everything that was generated, ensuring the code is clear, testable, well-organized, and coherent with the rest of the system. The AI can help write, but the responsibility for code quality remains with the developer.

At the end of the day, AI is a powerful tool, but like any tool, it must be used with care. When applied thoughtfully, it speeds up development, boosts productivity, and even helps explore new solutions.

But when used without planning, it can cause more harm than good. The developer’s role remains the same: to think, review, organize, and ensure the delivered code is ready to evolve with the system.