Reading and reviewing AI-written code

In this tutorial you will review a small piece of AI-written code the way a professional reviews a teammate's code. You will find three real problems in a function that looks fine and works for the example the AI showed, then fix it and test the fix.

Prerequisites: Python 3 installed (run python --version; on some machines the command is python3), VS Code and a free AI assistant from *Set up your machine*. You do not need to be a Python expert; the code is short and every line is explained.

When AI writes code, you are the reviewer, even as a beginner. The code might run and still be wrong in ways that matter: charging the wrong amount, crashing on unusual input, or exposing data. You are responsible for what you ship, and a client or interviewer will ask "why did you write it this way?" "The AI did it" is not an answer.

You do not need to understand every symbol. You need a method.

You asked an AI: "Write a Python function that calculates the total of a coffee order, given a list of items with item_id and qty." It gave this answer and an example that prints 240. Save it as order_total.py and run it.

# order_total.py
MENU = {"espresso": 120, "cappuccino": 180, "masala-chai": 90}


def calculate_total(items):
    total = 0
    for item in items:
        price = MENU[item["item_id"]]
        total += price * item["qty"]
    return total


if __name__ == "__main__":
    print(calculate_total([{"item_id": "espresso", "qty": 2}]))
    print(calculate_total([{"item_id": "espresso", "qty": -5}]))

Looks up each item's price in MENU, multiplies by quantity and adds up the result.

python order_total.py

On some machines use python3 instead of python.

The first line is right: 2 espressos at 120 is 240. The second line is the problem: a quantity of -5 gave a total of -600. A shop would owe the customer money. Running the happy path alone would never have shown you this.

Read line by line:

- MENU = {...} is a dictionary from item id to price in rupees. - for item in items: goes through each ordered item. - MENU[item["item_id"]] looks up the price. If the id is not in MENU, Python raises KeyError. - price * item["qty"] multiplies by quantity. Nothing checks that qty is sensible. - return total gives back the sum.

The code is correct only when the input is perfect. Real input is not. This is where the next steps come in.

That last row is a good sign worth keeping. If the AI had accepted a price from the request, a customer could send a price of 1 rupee. Never trust totals or prices that come from the client. This idea returns in *Security pitfalls in AI-written code*.

Prove the problems exist by running them. Add this to the bottom of the file temporarily, or open a Python terminal and import the function.

AI is a good second reader if you ask it to critique instead of just agree. Ask for a list of problems, then judge them yourself; sometimes it will flag things that are not real issues.

Act as a strict code reviewer. Review the [language] code below, which is meant to [what it should do].

1. List real bugs and risky edge cases, most serious first, with a one-line example input for each.
2. List anything that is unclear or missing (validation, error handling, security).
3. Do not rewrite the code yet. I will ask for the fix after I check your findings.

[paste code]

What to expect: A good review names negative quantity, unknown ids and an empty order, and gives an example input for each. Verify each claim by running it before believing it.

Explain the code below to a beginner, line by line. Then list any language features or functions I should look up in the official documentation, and 2 questions to test my understanding.

[paste code]

What to expect: If the explanation mentions a function you cannot find in the official docs, treat it with suspicion; AI sometimes invents functions.

Now ask the AI to fix only the problems you confirmed, or write the fix yourself. This version checks the input before calculating and raises a clear error. Replace the contents of order_total.py and run it.

# order_total.py
MENU = {"espresso": 120, "cappuccino": 180, "masala-chai": 90}


def calculate_total(items):
    if not items:
        raise ValueError("Order must have at least one item")
    total = 0
    for item in items:
        item_id = item.get("item_id")
        qty = item.get("qty")
        if item_id not in MENU:
            raise ValueError(f"Unknown item: {item_id}")
        if not isinstance(qty, int) or qty < 1 or qty > 20:
            raise ValueError(f"Quantity must be a whole number from 1 to 20, got {qty}")
        total += MENU[item_id] * qty
    return total


if __name__ == "__main__":
    print(calculate_total([{"item_id": "espresso", "qty": 2}, {"item_id": "masala-chai", "qty": 1}]))
    for bad in ([], [{"item_id": "espresso", "qty": -5}], [{"item_id": "mocha", "qty": 1}]):
        try:
            calculate_total(bad)
        except ValueError as error:
            print("Rejected:", error)

Rejects an empty order, unknown ids and bad quantities, and still takes prices from the server's MENU.

Check the first number by hand: 2 espressos is 240 plus 1 masala chai at 90, which is 330. In a real API, those ValueErrors would become a clear "400 Bad Request" message for the customer, which you will build in the API project.