Prompt Patterns (ReAct, ToT, Self-Refine)

Beyond Basic Prompting:

Basic prompting (zero-shot, few-shot, CoT) handles simple tasks well. But real-world problems are messy, multi-step, and require iteration. Advanced prompt patterns give the AI a structured framework for tackling these complex problems.

Think of it this way: basic prompting is like giving someone a task. Advanced patterns are like teaching them a problem-solving methodology - how to break down problems, explore options, take actions, and refine their work.

Real-World Analogy - Cricket Strategy:

A batsman does not just swing at every ball (basic prompting). A great batsman has patterns: read the bowler (observe), decide the shot (reason), play the shot (act), assess if it worked (evaluate), adjust strategy for next ball (refine). Advanced prompt patterns teach AI to think like a strategic cricketer, not just react.

The Three Patterns We Will Cover:

• ReAct (Reason + Act): AI thinks about what to do, takes an action (like calling a tool), observes the result, and repeats. Powers most AI agents.
• Tree-of-Thought (ToT): AI explores multiple solution paths simultaneously, evaluates each, and picks the best one. For creative and strategic problems.
• Self-Refine: AI generates a response, critiques its own work, and iteratively improves it. For quality-critical outputs.

What is ReAct?

ReAct (Reasoning + Acting) is a pattern where the AI alternates between thinking (reasoning about what to do next) and acting (taking an action like calling a tool or searching). After each action, it observes the result and reasons again. This loop continues until the task is complete.

The ReAct Loop:

  THOUGHT -> ACTION -> OBSERVATION -> THOUGHT -> ACTION -> ...

Thought: "I need to find the user's order status.
          Let me search the orders database."

Action:  search_orders(user_id="12345")

Observation: "Order #789: Shipped, arriving March 5"

Thought: "Found the order. It is shipped and arriving
          March 5. Let me format this for the user."

Action:  respond("Your order #789 has been shipped...
                  Expected delivery: March 5.")

Why ReAct Works So Well:

• Grounded reasoning: The AI does not hallucinate because it bases answers on real data from tool calls
• Transparent process: You can see WHY the AI made each decision (the thought step)
• Adaptive: If the first action does not give the right info, the AI can reason about what to try next
• Error recovery: If a tool call fails, the AI can reason about alternatives

Real Example - Travel Agent:

User: "Plan a weekend trip to Goa under Rs 15,000"

Thought 1: I need to find flight prices to Goa.
Action 1:  search_flights("BLR", "GOA", "weekend")
Observe 1: Cheapest: Rs 3,500 round trip

Thought 2: Budget has Rs 11,500 left. Find hotels.
Action 2:  search_hotels("Goa", budget=6000, nights=2)
Observe 2: Beach Resort: Rs 5,000 for 2 nights

Thought 3: Rs 6,500 left for food and activities.
           Let me find top activities.
Action 3:  search_activities("Goa", budget=3000)
Observe 3: Water sports Rs 1,500, Old Goa tour Rs 500

Thought 4: Complete plan within budget. Let me compile.
Final:     "Here is your Goa weekend plan: ..."

What is Tree-of-Thought?

Normal prompting follows ONE path of reasoning (linear). Tree-of-Thought (ToT) makes the AI explore MULTIPLE possible paths simultaneously, evaluate each, and select the best one. It is like a chess player thinking 3 moves ahead on multiple possible sequences.

Linear (Chain-of-Thought):
  Step 1 -> Step 2 -> Step 3 -> Answer

Tree-of-Thought:
  Step 1 -> Branch A -> Branch A.1 -> Evaluate: Score 7/10
         -> Branch B -> Branch B.1 -> Evaluate: Score 9/10 (Best!)
         -> Branch C -> Branch C.1 -> Evaluate: Score 4/10
  
  Select Branch B as the answer.

When to Use Tree-of-Thought:

• Creative tasks: Writing, design, brainstorming - where multiple approaches exist
• Strategy problems: Architecture decisions, business planning, game playing
• Optimization: Finding the best solution among many possible ones
• Debugging: When the bug could be in multiple places, explore each hypothesis

Practical ToT Prompt:

"I need to design a notification system for an e-commerce app.

Please generate 3 different architecture approaches.
For each approach:
1. Describe the architecture in 3-4 sentences
2. List pros and cons
3. Rate suitability 1-10 for our scale (10K users)

Then select the best approach and explain why."

AI generates:
  Approach 1: Polling-based (Score: 4/10)
  Approach 2: WebSocket (Score: 8/10)
  Approach 3: SSE + Message Queue (Score: 9/10)
  
  Recommendation: Approach 3 because...

ToT vs CoT:

What is Self-Refine?

Self-Refine is a pattern where the AI generates a response, then critiques its own work, then improves it based on the critique. This loop can repeat 2-3 times, each iteration producing better output. It is like a writer who drafts, edits, and polishes their work.

The Self-Refine Loop:

  GENERATE (Draft 1)
      |
  CRITIQUE ("What is wrong with this?")
      |
  REFINE (Draft 2 - addresses the critique)
      |
  CRITIQUE ("Better, but still missing X")
      |
  REFINE (Draft 3 - final polished version)

Self-Refine Prompt Structure:

Step 1 - Generate:
"Write a product description for a wireless earphone
 targeted at college students in India."

Step 2 - Critique:
"Review this product description. Score it on:
 - Clarity (1-10)
 - Persuasiveness (1-10)
 - Target audience fit (1-10)
 List specific improvements needed."

Step 3 - Refine:
"Based on the critique above, rewrite the product
 description addressing every point. Make it better."

(Repeat Steps 2-3 if needed)

When Self-Refine Shines:

• Writing: Blog posts, marketing copy, documentation - where polish matters
• Code: Generate code, then review for bugs/performance, then fix
• Emails: Draft, check tone and clarity, refine
• Presentations: Create slides, critique structure and flow, improve

Diminishing Returns:

Self-Refine has diminishing returns after 2-3 iterations. The first critique catches major issues. The second catches minor ones. A third rarely adds value and wastes tokens. Know when to stop.

Pattern Selection Guide:

Combined Example - AI Code Reviewer:

Phase 1: ReAct (Gather Context)
  Thought: Need to understand the code change
  Action:  read_file("auth-middleware.js")
  Observe: [file contents]
  Thought: Need to check related tests
  Action:  read_file("auth-middleware.test.js")
  Observe: [test file contents]

Phase 2: ToT (Explore Issues)
  Branch A: Security review -> Found SQL injection risk
  Branch B: Performance review -> Found N+1 query
  Branch C: Code style review -> Minor naming issues
  Prioritize: Security > Performance > Style

Phase 3: Self-Refine (Polish Review)
  Draft review comment
  Critique: "Too harsh, need to be constructive"
  Refine: Rewrite with suggestions, not just criticism
  
Final: Professional, thorough code review

Other Notable Patterns:

• Reflexion: Like Self-Refine but with memory across episodes. The AI remembers what went wrong before and avoids the same mistakes.
• Plan-and-Solve: AI creates a plan first, then executes step by step. Good for complex multi-step tasks.
• Role-Play Debate: AI takes multiple perspectives (for/against) and debates with itself to reach a balanced conclusion.

Q: What is the ReAct pattern and why is it important?

Q: How does Tree-of-Thought differ from Chain-of-Thought?

Q: What is Self-Refine and when should you use it?

Q: How would you combine these patterns in a real AI agent?

Q: What are the trade-offs of using advanced prompt patterns?