India's 1.5 million annual IT graduates face an industry that's moving on without them

Introduction

In today's rapidly evolving technology landscape, India's IT industry is facing a major shift. With the rise of agentic AI, traditional coding skills are no longer sufficient for new hires. This tutorial will teach you how to build a simple AI assistant that can help automate code review processes, a key skill that modern IT professionals need to master. By the end of this tutorial, you'll have created a basic AI-powered code analysis tool that can identify common coding issues and suggest improvements.

Prerequisites

Before starting this tutorial, you'll need:

• A computer with internet access
• Python 3.8 or higher installed
• Basic understanding of Python programming
• Access to a code editor (VS Code, PyCharm, or any text editor)

Why these prerequisites? Python is the most popular language for AI development, and having a basic understanding of it will help you follow along. We'll be using simple AI concepts that don't require advanced machine learning knowledge.

Step-by-Step Instructions

1. Set up Your Development Environment

First, we need to create a new Python project directory and install the required packages. Open your terminal or command prompt and run:

mkdir ai_code_reviewer
 cd ai_code_reviewer
 python -m venv venv
 source venv/bin/activate   # On Windows: venv\Scripts\activate

Next, install the required packages:

pip install openai python-dotenv

Why this step? We're creating a separate environment to avoid conflicts with other Python projects. The packages we're installing will help us connect to AI services and manage our API keys securely.

2. Create Your API Key Configuration

Sign up for an OpenAI account at platform.openai.com and get your API key. Create a file called .env in your project directory:

OPENAI_API_KEY=your_actual_api_key_here

Why this step? Keeping your API key in a separate file prevents it from being accidentally shared in public repositories. The python-dotenv package will help us load this key into our Python script.

3. Create the Main Code Review Script

Create a file called code_reviewer.py and add the following code:

import os
from dotenv import load_dotenv
import openai

# Load environment variables
load_dotenv()

# Configure OpenAI API key
openai.api_key = os.getenv('OPENAI_API_KEY')

def analyze_code(code_snippet):
    """Analyze code snippet for common issues"""
    prompt = f"""
    Please analyze the following Python code snippet for common issues:
    
    {code_snippet}
    
    Provide feedback on:
    1. Code readability
    2. Potential bugs
    3. Best practices
    4. Performance improvements
    
    Format your response as a list of bullet points.
    """
    
    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "You are a helpful code review assistant."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=500,
            temperature=0.3
        )
        
        return response.choices[0].message.content
    except Exception as e:
        return f"Error analyzing code: {str(e)}"

# Example usage
if __name__ == "__main__":
    sample_code = """
    def calculate_sum(numbers):
        total = 0
        for i in range(len(numbers)):
            total += numbers[i]
        return total
    """
    
    print("Code Analysis:")
    print(analyze_code(sample_code))
    

Why this step? This is the core of our AI code reviewer. The script sets up the connection to OpenAI's API and creates a function that sends code snippets to the AI for analysis. We're using a prompt that tells the AI exactly what to look for in the code.

4. Test Your Code Reviewer

Run your script to see the AI's analysis:

python code_reviewer.py

You should see output similar to:

Code Analysis:
- The code works correctly but could be simplified using Python's built-in sum() function
- Consider using 'for number in numbers:' instead of indexing for better readability
- The function name 'calculate_sum' is clear and descriptive
- No major performance issues detected

Why test this? Testing ensures your setup is working correctly and gives you a chance to see how AI can help with code review, which is one of the skills the IT industry is now emphasizing.

5. Enhance Your Code Reviewer

Let's improve our code reviewer by adding a function to analyze multiple code files:

def analyze_multiple_files(file_paths):
    """Analyze multiple code files"""
    results = {}
    for file_path in file_paths:
        try:
            with open(file_path, 'r') as file:
                code = file.read()
            results[file_path] = analyze_code(code)
        except Exception as e:
            results[file_path] = f"Error reading file: {str(e)}"
    return results

# Add this to your main section
if __name__ == "__main__":
    # Test with sample code
    sample_code = """
    def calculate_sum(numbers):
        total = 0
        for i in range(len(numbers)):
            total += numbers[i]
        return total
    """
    
    print("Code Analysis:")
    print(analyze_code(sample_code))
    
    # Test with multiple files
    # results = analyze_multiple_files(['file1.py', 'file2.py'])
    # for file_path, analysis in results.items():
    #     print(f"\n{file_path}:\n{analysis}")

Why enhance this? Real-world code review involves analyzing multiple files, so extending our tool to handle this makes it more practical for actual use.

6. Create a Simple User Interface

Let's make our tool more user-friendly by adding a simple text interface:

def interactive_reviewer():
    """Interactive code review interface"""
    print("AI Code Reviewer - Type 'quit' to exit")
    
    while True:
        print("\nEnter code snippet to analyze (or 'quit' to exit):")
        code = input()
        
        if code.lower() == 'quit':
            break
        
        if code.strip():
            print("\nAnalysis Result:")
            print(analyze_code(code))
        else:
            print("Please enter some code to analyze.")

# Replace the main section with this
if __name__ == "__main__":
    interactive_reviewer()

Why this enhancement? An interactive interface makes it easier to test different code snippets and demonstrates how modern IT tools need to be user-friendly and accessible to non-experts.

Summary

In this tutorial, you've built a basic AI-powered code reviewer that can analyze Python code snippets and provide feedback on readability, potential bugs, best practices, and performance. This demonstrates how modern IT professionals need to work with AI tools rather than just traditional coding skills.

The key takeaways are:

• AI tools like OpenAI's GPT can automate code review processes
• Understanding how to integrate AI APIs into your projects is crucial for modern IT work
• Code analysis tools help identify improvements that might be missed by human reviewers

This simple project shows how the IT industry is moving toward AI-assisted development, which is why India's graduates need to learn these new skills to stay competitive in the job market.