Asking for Changes and Iterating

Close but not quite right

Most of the time, Claude Code won't nail it on the first try.

That's normal, not a failure. You describe what you want, Claude Code gives you something, and you refine it together. The result usually gets better with each round.

Your instinct might be to start over. Don't. Claude Code remembers everything you've said in the current conversation. Each new message builds on what came before. That means you can say "change the dates to month-day-year format" without re-explaining the whole task.

This back-and-forth is called iteration. It's the same thing you'd do with a colleague: "This looks great, but can you move the totals to the top?"

Be specific about what's wrong

The biggest mistake when iterating is being too vague about what needs to change.

Specific feedback tells Claude Code exactly what to change and exactly what to keep.

The colleague test from the previous section applies here too. If you told a colleague "that's wrong," they'd ask "what's wrong with it?" Save both of you the extra step.

Three types of iteration

Not every adjustment is the same. Here are the three most common kinds, with examples of what to say.

Small fixes

The result is mostly right but has specific things to correct.

• "Change the title from 'Q4 Report' to 'Q4 2026 Revenue Summary'"
• "The phone numbers should all have dashes, not dots"
• "Remove the last two rows, those are test entries, not real data"

These are the fastest rounds. One clear instruction, one quick change.

Direction changes

The approach is wrong, but the work so far is still useful.

• "Actually, instead of a table, make this a bulleted list grouped by region"
• "Keep all the data, but sort by date instead of by customer name"
• "I like the analysis, but present it as a one-page summary instead of a detailed breakdown"

These take a bit more work from Claude Code, but because it already has the data and context from the conversation, it doesn't need to start from scratch.

Pushing back

Sometimes Claude Code changes something you wanted to keep, or makes a decision you disagree with. Push back directly.

• "Actually, keep the original column names. Don't rename them"
• "I want the raw numbers, not rounded to the nearest thousand"
• "Don't add that extra section. Stick to what I asked for"

Claude Code doesn't have feelings to hurt. Be direct about what you want, and it will adjust.

Building on previous work

Iteration gets really useful when you stack changes across multiple rounds.

In your first message, you might ask Claude Code to clean up a spreadsheet. In your second, you ask it to add a summary row. In your third, you ask for a chart based on the cleaned data.

Each request builds on the last. Claude Code knows what it already did, so you don't need to repeat yourself.

Here's what this looks like in practice:

Round 1: "Clean up the customer data in contacts.csv. Fix the phone number formatting and remove any duplicate entries."

Round 2: "Now add a column called 'Region' based on the area code of each phone number."

Round 3: "Create a summary showing how many customers are in each region."

By round three, Claude Code has already cleaned the data, deduplicated it, and added the region column. You're building on a foundation, not starting from zero.

Tip: If you're planning several steps, mention them upfront: "I want to clean this data, then add a region column, then get a summary. Let's start with the cleanup." This helps Claude Code make better choices in the early rounds because it knows where you're headed.

The two-correction rule

If you've corrected Claude Code on the same issue twice and it still isn't getting it right, stop iterating.

Start a new conversation instead.

This might feel counterintuitive. You've spent time building up context, so why throw it away?

Because after several rounds of correction, the conversation has accumulated mixed signals. Claude Code is trying to reconcile your original instructions, its first attempt, your corrections, its second attempt, and yet more corrections. All that back-and-forth can make things worse, not better.

A fresh start with one clear prompt, written with the benefit of everything you learned from the failed attempts, almost always produces better results than a sixth round of "no, not like that."

Think of it like giving directions. If someone has taken two wrong turns following your instructions, it's faster to say "go back to the start and take Main Street" than to keep saying "no, turn around, go left, no your other left."

Here's how to do it:

1. Note what went wrong so you can be more specific this time
2. Type /clear to reset the conversation
3. Write a new, more detailed instruction that addresses the issues upfront

Your CLAUDE.md file (covered later in this module) is still loaded after a /clear, so any preferences you've saved there carry over automatically.

How many rounds is normal?

There's no magic number, but here's a rough guide:

Most tasks settle in two to three rounds. If you find yourself going beyond five, that's a strong signal to start fresh.

Interrupting Claude Code mid-response

Sometimes you can tell right away that Claude Code is heading in the wrong direction. You don't have to wait for it to finish.

Press Escape once to interrupt it. Claude Code stops what it's doing, and you can type a correction immediately.

This saves time. If you asked for a bar chart and Claude Code is building a pie chart, there's no point waiting for a finished pie chart before saying "I wanted bars."

When "good enough" is good enough

Not every result needs to be perfect.

If Claude Code gives you a report that's 90% what you need and you'll spend another 20 minutes iterating on the last 10%, ask yourself: is the remaining gap worth the time?

For a quick internal analysis, "good enough" might be exactly right. For a report going to your CEO, another round of polish is probably worth it.

The judgment is yours. Claude Code will keep iterating as long as you ask it to. Knowing when to stop is part of the skill.

What's next

You know how to give instructions, review results, and iterate when things aren't perfect.

But sometimes a conversation goes genuinely off the rails. Claude Code misunderstands your intent, makes changes you didn't expect, or heads in a direction that no amount of correction can fix. Next, we'll walk through a real scenario where that happens, and how to handle it.