DailyRNG
Login
Basic

Your first full review

Time to do a whole review end to end. Take one small file, ask the AI to look it over, then fix the top issue yourself. It feels slow the first time, which is the point, you're building a habit, not shipping fast.

What you will see

It works. Worth using the built-in sum() for clarity.

About 2 min of reading

Quick check

Before this new lesson, one small question about the lesson you just finished. Recall it, do not look it up.

Try It

A whole review done end to end is the habit you are building. I ask an AI to look at a small file, fix the top bug, keep the rest for later, and write down one lesson so the bugs you spot on your own keep growing.

1

One focused review stays small enough to act on. I ask an AI to review a divide function and print the first bug as the one to fix while the second is saved for another pass.

def review(code): bugs = ["division by zero", "unused variable"] return bugs bugs = review("divide function") print(f"Bug fixed: {bugs[0]}") print(f"Saved for later: {bugs[1]}")

Before you run it, say out loud what it will print. Then open the answer.

What it prints
Bug fixed: division by zero Saved for later: unused variable
Keep reviews tight. Review a single function or one file, not a whole project, so the notes stay focused enough to follow through on.
2

A couple of sentences recording what you changed and why become a map of your own growth. I write down two changes with their reasons and print each one as a record of the review.

changes = [] changes.append(("Fixed division by zero", "Guard against b == 0")) changes.append(("Left style tip", "Unused variable review later")) for what, reason in changes: print(f"{what}, {reason}")

Before you run it, say out loud what it will print. Then open the answer.

What it prints
Fixed division by zero, Guard against b == 0 Left style tip, Unused variable review later
Write down what you changed and why. Over time you will see which kinds of bugs keep showing up and start fixing them before the AI does.
3

A single focused review of one loop stays small and teaches one thing. I ask an AI to review a simple loop and print its note about using the built-in sum for clarity.

def review_loop(): return "It works. Worth using the built-in sum() for clarity." print(review_loop())

Before you run it, say out loud what it will print. Then open the answer.

What it prints
It works. Worth using the built-in sum() for clarity.
Review one thing at a time. Learn one lesson, apply it, and move on rather than chasing every note at once.

Put it in order

Before you write anything, put these lines back in the right order. Click a line to move it up one step. This support step is easier than writing code from scratch, and it is here to make the last example stick.

Data Flow

Review one file, fix the bugs, and jot down one thing to remember next time.
1 Pick a single file
↓
2 Ask the AI to review it
↓
3 Fix the real bugs
↓
4 Write down one lesson
Line by line

Read the first example one line at a time. A line that prints shows what appears on screen; the rest set things up quietly.

def review(code): sets nothing on screen
bugs = ["division by zero", "unused variable"] sets nothing on screen
return bugs sets nothing on screen
bugs = review("divide function") sets nothing on screen
print(f"Bug fixed: {bugs[0]}") Bug fixed: division by zero
print(f"Saved for later: {bugs[1]}") Saved for later: unused variable
Why this works
One file at a time

Keep reviews tight. Review a single function or one file, not a whole project. Focused reviews produce focused notes, and focused notes are the only ones you'll actually follow through on.

Write down one lesson per review

After each review, note just one thing you learned. That single habit compounds. In a few months the bugs you spot on your own will be the ones you used to have to ask the AI about.

Examples

A review that fits on one screen

You: "Review this file for bugs."
AI: "Found two bugs and three style tips. Bug one: division by zero. Bug two: an unused variable."

def divide(a, b):
    temp = 0
    return a / b   # crashes if b is zero

You patch the division bug, leave the unused variable for another pass, and jot the rest down. That's the entire loop: read, fix the real problem, save the rest. No need to chase every note at once.

Keeping a record of what you changed

You: "Review this small script."
AI: "One bug and one style tip."
You: "Fixed the bug. Leaving the style tip for now."

Write down what you changed and why. A couple of sentences is enough. Over time that little record becomes a map of your own growth, you'll see which kinds of bugs keep showing up, and start fixing them before the AI does.

Reviewing just one loop

total = 0
for n in numbers:
    total = total + n   # correct, a little clunky

You: "Review this loop."
AI: "It works. Worth using the built-in sum() for clarity."

A single focused review stays small enough to act on. You learn one thing, apply it, move on. That's how a full review loop actually looks when you slow down.

Words this lesson uses

Each one is defined here on this site. Open the entry for the full definition and the other words it points at.

← Not every note needs a fix
Previous Lesson
Not every note needs a fix
Next Lesson
Getting the AI to find the security problems, not just the obvious ones
Getting the AI to find the security problems, not just the obvious ones →