When I'm unsatisfied with Claude's output, should I continue in the same conversation or open a new one?
Almost always continue in the same conversation — don't close and reopen.
Reason: Claude remembers everything you've said within the same conversation. If you close and reopen, it starts from zero again — all your background context, previous outputs, and feedback disappear. You have to re-explain, and it has to re-guess your intent.
Continuing to iterate in the same conversation, Claude can precisely understand your revision requests based on context. Saying 'this version is better than the last, but the second paragraph is too long and the tone too formal — please adjust' — it knows where version one is, what 'better than the last' means, and exactly what needs to change. This is far more effective than reopening a conversation and re-explaining from scratch.
The only appropriate time to open a new conversation: your current task is complete and you're starting a completely unrelated new task; or you realize the context setup from the beginning was wrong and needs a complete reset.
What kind of feedback makes iteration most efficient? Is there a feedback framework?
Effective feedback typically contains three elements: evaluation (what's good and bad about this output), direction (which way I want it to change), magnitude (how much change).
Several efficient feedback formats:
'X is right, but Y needs changing': 'The overall structure is correct, but the second paragraph is too long and the closing is too polite — please compress the second paragraph to three sentences and make the closing more direct.'
Score + problem description: 'This version is 6/10. Problems: tone too formal, no concrete examples, weak ending. Please revise for these three issues.'
Provide a comparison example: 'The feeling I want is more like this: [paste example you like]. What's the main difference between this and the current version? Please revise in that direction.'
Least effective feedback: 'Wrong, try again' — this gives Claude zero information, it can only guess. 'Make it better' — too vague, Claude doesn't know which direction 'better' is.
After iterating several rounds, the conversation gets longer and longer — does this affect Claude's output quality?
Yes — this is the practical impact of Context Window limitations. Claude has an upper limit on processable conversation length (currently approximately 200,000 tokens), and as conversations approach this limit, Claude's memory of early conversation may start to blur or become inaccurate.
In practice, for most workplace tasks, a single conversation is unlikely to truly exceed the Context Window limit — unless you've uploaded very long documents in the conversation, or the conversation itself runs dozens of rounds.
If you notice Claude starting to 'forget' requirements you mentioned early in a conversation after extended iteration, try: 'Please review the main requirements I stated in this conversation, then re-evaluate your latest version against those requirements' — having Claude actively trace the conversation's context. If the conversation is genuinely too long, the most effective approach is opening a new conversation, bringing the final version and the latest revision requirements, and continuing from a clean state.
What's the relationship between Iterative Prompting and Prompt Templates? When to use which?
They solve different problems and work best together:
Prompt Templates solve: 'every time I need to do this type of task, I have to re-think how to give instructions.' They're pre-designed prompt frameworks for specific task types, giving each similar task a stable starting point.
Iterative Prompting solves: 'Claude's first output has a gap from what I need — how do I adjust it into place.' It's the process of giving feedback within the same conversation based on actual output.
Optimal combination: use Prompt Templates to establish the task's starting point (ensuring baseline quality from the first output), then use Iterative Prompting within the same conversation to adjust the output to exactly what you need (bridging case-specific differences the template can't cover). With a good template, iteration rounds are typically fewer (starting point is more accurate); with iteration capability, templates don't need to be perfect (adjustments can be made afterward).
Iterative Prompting in Practice: Multi-Round Adjustment of Product Copy
You need to write a product introduction for a new feature, intended for business users without technical backgrounds.
Round 1: 'Please write a 150-word product introduction for our AI automated data reporting feature, aimed at small-to-medium business executives without technical backgrounds.'
Claude's output: an introduction using technical terms like 'AI algorithms' and 'automated pipelines.'
Your feedback (Round 2): 'The language is too technical — the target audience doesn't understand these terms. Please rewrite in more everyday language, emphasizing 'how much time is saved' and 'no IT department help needed.' Remove all technical jargon.'
Claude's output: improved, but a bit too colloquial, lacking professional feel.
Your feedback (Round 3): 'The direction is right, but the tone is too casual and lacks a business feel. While maintaining simple language, please add a specific number (e.g., hours saved) and a call to action.'
Round 3 output: a product introduction meeting your needs — simple language, numbers, professional feel. Three rounds of iteration, far more efficient than re-thinking from scratch.
Deep Iteration vs. Quick Delivery: Iterative Prompting's Core Trade-off
More iteration rounds mean more precise output but more time spent. For one-time, low-stakes tasks, one or two rounds suffice. For high-stakes external documents (client proposals, publicly released content), a few more rounds to ensure quality is worthwhile.
A practical judgment principle: think about how many people will see this output and what the cost is of them seeing 'not good enough' output. An internal note seen by 1 person versus external copy seen by 1,000 people justifies completely different numbers of iteration rounds.
Most efficient approach: use good prompts to get the first-round output as close to the target as possible (reducing needed iterations), then only iterate where genuinely needed.