Skip to main content

​
Message Editing Overview

ZeroTwo allows you to edit your messages and regenerate AI responses, giving you full control over the conversation flow and helping you get the best possible answers.
Editing a message creates a new conversation branch, preserving the original path while exploring alternatives.

​
Editing Your Messages

Modify your prompts to clarify questions, fix typos, or try different approaches.

​
How to Edit Messages

1

Hover over your message

Move your cursor over any message you’ve sent to reveal the message actions.
2

Click the Edit button

Click the ✏️ Edit icon that appears on hover.Keyboard shortcut: Press E while hovering
3

Modify the message

The message text becomes editable in the input field:
  • Make your changes
  • Fix typos or unclear phrasing
  • Add more context or details
  • Completely rewrite if needed
4

Save and regenerate

Click Save & Regenerate or press Enter to:
  • Save your edited message
  • Generate a new response based on the changes
  • Create a new conversation branch
The original message and response are preserved in the conversation history - you can always go back.

​
When to Edit Messages

Make your intent clearer:Original message:
How do I make this faster?
Edited message:
How can I optimize this Python function to run faster? 
It currently takes 2 seconds to process 10,000 items.
Adding specific details helps AI provide more targeted solutions.

​
Regenerating Responses

Get a new AI response without changing your original message.

​
Basic Regeneration

1

Find the regenerate button

Hover over any AI response to reveal action buttons.
2

Click Regenerate

Click the 🔄 Regenerate button.Keyboard shortcut: Press R while hovering over the response
This generates a new response using the same prompt and context.
3

View new response

AI generates a fresh response:
  • May offer different approaches
  • Could provide additional details
  • Might catch things missed in the first response
4

Compare responses

Use the navigation arrows to switch between response variations:
  • ◀️ Previous response
  • ▶️ Next response
  • Shows “Response 1 of 3” counter

​
Why Regenerate?

When the response lacks detail:Sometimes AI responses are too brief or miss important aspects. Regenerating can provide:
  • More comprehensive explanations
  • Additional examples
  • Different perspectives
  • Better code solutions
Try regenerating 2-3 times to see different approaches, then pick the best one.
When code or solutions don’t work:
  • Syntax errors in generated code
  • Logic mistakes
  • Incorrect assumptions
  • Outdated information
Regenerating often produces a working solution.
Explore alternative solutions:
  • Try different algorithms
  • See various implementation styles
  • Get creative alternatives
  • Compare multiple solutions
Example: Ask for a sorting algorithm and regenerate to see bubble sort, quick sort, and merge sort implementations.
When AI misunderstands:Sometimes AI interprets your question differently than intended. Regenerating might:
  • Catch the intended meaning
  • Provide a better interpretation
  • Ask clarifying questions
If regeneration doesn’t help, edit your original message for clarity.

​
Regenerate with Changes

Modify settings before regenerating for different results. Options to change:

Switch Models

Change the AI model before regenerating:
  • Try a more powerful model
  • Use a faster model
  • Switch to a specialized model
Example: Switch from GPT-4 to Claude 3.5 for different coding style

Adjust Temperature

Control response creativity:
  • Lower (0.3-0.5): More focused, deterministic
  • Medium (0.7): Balanced
  • Higher (0.9-1.0): More creative, varied
Access in model settings

Enable Tools

Add tools before regenerating:
  • Enable web search for current info
  • Activate code interpreter
  • Turn on image generation
See active tools in chat header

Add Context

Include additional context:
  • Upload relevant files
  • Reference previous messages
  • Add custom instructions
Helps AI understand better

​
Response Variations

Navigate between multiple response variations for the same prompt.

​
Managing Variations

Response counter: Shows “Response 2 of 4” above each AI message Navigation:
  • ◀️ Previous: View earlier response
  • ▶️ Next: View next response
  • Each variation is saved and accessible
Generate multiple variations, then pick the best one. You can always switch back to any previous variation.

​
Comparing Variations

1

Generate multiple responses

Click regenerate several times to create variations
2

Navigate between them

Use arrow buttons to switch between responses
3

Evaluate each one

Compare based on:
  • Accuracy and correctness
  • Completeness of explanation
  • Code quality (if applicable)
  • Clarity and readability
  • Helpfulness for your specific need
4

Continue from best

Continue the conversation from your preferred variation
All variations are preserved until you delete the message or clear the conversation.

​
Conversation Branches

Editing creates branches in your conversation tree, allowing you to explore different paths.

​
Understanding Branches

How branching works: 
Original path:
User: "Create a sorting function"
AI: [Response about bubble sort]

Edit and branch:
User: "Create a sorting function with O(n log n) complexity"
AI: [Response about merge sort]
Both paths exist in the conversation history.

​
Branch Navigation

Visual indicators:
  • 🔀 Branch icon shows when multiple paths exist
  • Breadcrumb trail shows current branch
  • Click branch points to switch paths
Create new branches:
  1. Edit any message
  2. New response creates a branch
  3. Continue from that point
  4. Original path preserved
Branches let you explore different approaches without losing your work!

​
Advanced Editing Techniques

​
Iterative Refinement

Progressively improve responses through editing:
1

Start broad

Explain how React hooks work
2

Refine with edit

Explain how React hooks work, focusing on useState and useEffect 
with practical examples
3

Further refine

Explain how React hooks work, focusing on useState and useEffect. 
Show examples of common pitfalls and how to avoid them, especially 
with dependency arrays in useEffect
4

Perfect the response

Continue editing and regenerating until you get exactly what you need

​
A/B Testing Prompts

Test different phrasings to find what works best: Test variations:
  1. Ask the same question different ways
  2. Edit to try alternative phrasings
  3. Compare the quality of responses
  4. Learn which prompt styles work best
Example A: 
Make this code better
Example B: 
Refactor this code for better performance, readability, and maintainability. 
Add comments explaining key sections.
Example B typically produces better results due to specific, clear instructions.

​
Chaining Edits

Build on previous edits for complex tasks: 
Original: "Create a todo app"
Edit 1: "Create a todo app with React"
Edit 2: "Create a todo app with React and TypeScript"
Edit 3: "Create a todo app with React, TypeScript, and local storage persistence"
Each edit adds requirements while maintaining context.

​
Best Practices

Beyond fixing typos:
  • Add specific requirements
  • Include constraints or limitations
  • Mention your skill level
  • Specify desired output format
Good edit:
Create a Python function to sort a list of dictionaries by a specific key, 
handling missing keys gracefully. Include error handling and type hints.
When to regenerate:
  • ✅ Response is close but needs improvement
  • ✅ Want to see alternative approaches
  • ✅ Technical error in the response
  • ✅ Need more detail
When to edit instead:
  • ❌ Your question was unclear
  • ❌ You forgot important context
  • ❌ You need something different
  • ❌ Requirements changed
Branch management tips:
  • Create branches for major direction changes
  • Keep branches focused on specific approaches
  • Review all branches before finalizing
  • Delete unsuccessful branches to reduce clutter
  • Document why you chose a particular branch
Name your mental branches: “Performance approach” vs “Readability approach”
Powerful workflow:
  1. Edit message to improve clarity
  2. Regenerate to get fresh response
  3. If not satisfied, regenerate again
  4. Switch models for different perspective
  5. Pick the best variation
This combination often yields the best results.

​
Keyboard Shortcuts

Speed up your workflow with shortcuts:
ActionShortcutDescription
Edit messageE (hover)Edit the message under cursor
RegenerateR (hover)Regenerate response under cursor
Previous variationAlt + ←View previous response variation
Next variationAlt + →View next response variation
Cancel editEscCancel editing and restore original
Save editCmd/Ctrl + EnterSave edit and regenerate
Enable keyboard shortcuts in Settings > General > Keyboard Shortcuts

​
Examples

​
Example 1: Refining a Code Request

Original message: 
Write a function to validate emails
After seeing a basic response, edit to: 
Write a function to validate emails according to RFC 5322 standard. 
Include support for international domains. Return detailed error messages 
for different validation failures. Write in TypeScript with full type safety.
Result: Much more comprehensive and production-ready solution.

​
Example 2: Getting Multiple Perspectives

Your message: 
Should I use REST or GraphQL for my API?
After first response, regenerate 2-3 times to see:
  • Response 1: Strong REST recommendation with practical reasons
  • Response 2: Balanced comparison with use cases for each
  • Response 3: GraphQL recommendation with modern app context
Compare all three to make an informed decision.

​
Example 3: Debugging Through Iteration

Start: 
This code doesn't work [paste code]
Edit after seeing the fix attempt: 
This React code doesn't work. I get "Cannot read property 'map' of undefined" 
on line 15. The data comes from an API call. Here's the full component: [code]
Regenerate if fix doesn’t work, or edit again: 
The fix didn't work. Here's the API response structure: [paste response]. 
The error still happens on initial render before data loads.
Progressive detail leads to the solution.

​
Troubleshooting

Check these items:
  • Hover directly over your message
  • Ensure you’re hovering over YOUR messages (not AI responses)
  • Check if conversation is locked/archived
  • Refresh the page if buttons don’t appear
Possible issues:
  • Network connection problems
  • Message too long (exceeds token limit)
  • Browser blocking save
Solutions:
  • Check internet connection
  • Shorten the edited message
  • Try in a different browser
  • Clear browser cache
Why this happens:
  • Temperature setting too low
  • Highly deterministic query
  • Model cached the response
Solutions:
  • Increase temperature in model settings
  • Edit message slightly before regenerating
  • Switch to a different model
  • Add randomness to the prompt (“Suggest 3 different approaches…”)
Navigation help:
  • Look for branch indicator icons
  • Use breadcrumbs to track path
  • Click on earlier messages to see branches
  • Consider starting a new chat if too complex
If branches become confusing, copy the best responses into a new chat for a clean start.

​
Next Steps

Custom Instructions

Set default preferences for all responses

Conversation Branches

Deep dive into branch management

Switch Models

Learn which models work best for different tasks

Canvas

Iteratively refine content in Canvas
Master editing and regeneration to get the perfect response every time!