Skip to main content

​
About Chat

The chat panel is your primary interface for interacting with Cheetah AI. It provides a conversational experience where you can ask questions, request code changes, explore your codebase, and execute complex development tasks. The AI maintains context throughout your conversation, allowing you to build on previous messages and refine your requests iteratively. Unlike simple code completion tools, the chat interface enables rich, multi-turn conversations where you can discuss problems, explore solutions, and collaborate with the AI on implementation details. The AI remembers what you’ve discussed and can reference earlier parts of the conversation when responding to new messages.

​
Opening Chat

There are several ways to open the chat panel:
  • Press Cmd+L (macOS) or Ctrl+L (Windows/Linux) from anywhere in the editor
  • Click the chat icon in the sidebar
  • Use the Command Palette (Cmd+Shift+P) and search for “Open Chat”
The chat panel opens in the sidebar, giving you a dedicated space for conversation while keeping your code visible in the main editor area. You can resize the panel by dragging its edge, or collapse it when you need more screen space for code.

​
Providing Context

The quality of AI responses depends heavily on the context you provide. Cheetah AI offers several ways to include relevant information in your messages, helping the AI understand exactly what you’re working on and what you need.

​
File References

Reference specific files in your messages using the @ symbol followed by the file path. This tells the AI to read and consider that file when responding to your message. 
@src/components/Button.tsx - Can you add a loading state to this component?
When you reference a file, the AI reads its contents and uses that information to provide more accurate and relevant responses. This is particularly useful when asking about specific code or requesting changes to particular files. You can reference multiple files in a single message: 
@src/api/users.ts @src/types/user.ts - How do these files work together?

​
Code Selections

The fastest way to provide context is by selecting code before opening chat. When you have code selected and press Cmd+L, the selection is automatically included in your message.
  1. Select the code you want to discuss or modify in the editor
  2. Press Cmd+L to open chat
  3. The selected code appears in your message as context
  4. Type your question or request and send
This workflow is ideal for asking questions about specific code blocks, requesting modifications to selected functions, or getting explanations of complex logic.

​
Folder Context

For broader context, you can reference entire directories: 
@src/api/ - Explain the API structure and how endpoints are organized
When you reference a folder, the AI examines its contents and structure to understand how files are organized and how they relate to each other. This is useful for understanding architectural patterns or when your question spans multiple related files.

​
Writing Effective Prompts

The way you phrase your requests significantly impacts the quality of AI responses. Clear, specific prompts with relevant context produce better results than vague or ambiguous requests.

​
Be Specific

Vague prompts lead to generic responses. Include specific details about what you want to accomplish, where the change should be made, and any constraints or requirements. Less effective: 
"Fix the bug"
More effective: 
"The login form submits twice when clicking the button. Fix the double-submission
issue in LoginForm.tsx by disabling the button during submission and preventing
the default form behavior."

​
Provide Context

Even when the AI can read your files, explicitly stating relevant context helps it understand your intent and constraints. Less effective: 
"Add validation"
More effective: 
"Add email validation to the signup form in SignupForm.tsx. It should check for
valid email format using a regex pattern and display an error message below the
input field when validation fails. Use our existing ErrorMessage component for
consistency."

​
Specify Constraints

If you have preferences about implementation approach, libraries to use, or patterns to follow, include them in your prompt. Less effective: 
"Create a component"
More effective: 
"Create a Card component using TypeScript and Tailwind CSS. It should accept
title (required), description (optional), and image (optional) props. Include
proper accessibility attributes like role and aria-labels. Follow our existing
component patterns in src/components/."

​
State Expected Behavior

When reporting issues or requesting changes, describe both the current behavior and what you expect to happen. Less effective: 
"This doesn't work"
More effective: 
"The useEffect hook runs on every render instead of only when userId changes.
I expect it to only fetch user data when the userId prop updates. Currently
it's causing unnecessary API calls and performance issues."

​
Chat Features

​
Code Blocks in Responses

When the AI generates code, it appears in syntax-highlighted code blocks with action buttons: Copy - Copies the code to your clipboard for manual pasting Apply - In Agent mode, applies the code change directly to the relevant file. The AI determines where the code should go based on context. Insert - Inserts the code at your current cursor position in the editor

​
Conversation History

Your conversations are automatically saved and accessible from the sidebar. This allows you to:
  • Return to previous conversations and continue where you left off
  • Search through past conversations to find solutions you’ve discussed before
  • Reference earlier discussions when working on related problems
Each conversation maintains its own context, so starting a new conversation gives you a fresh slate without the context of previous discussions.

​
Multi-turn Conversations

The AI maintains context throughout a conversation, allowing you to build on previous messages without repeating information. 
You: Create a User model with name and email fields
AI: [creates User model with name and email]

You: Add a password field with bcrypt hashing
AI: [updates the same model, adding password field and hashing logic]

You: Now create a registration endpoint that uses this model
AI: [creates endpoint that references the User model from earlier messages]
This conversational memory makes it easy to iteratively develop features, refine implementations, and explore alternatives without starting over each time.

​
Inline Editing with Cmd+K

For quick edits without opening the full chat panel, use the inline editor. This provides a streamlined interface for making targeted changes to selected code. How to use inline editing:
  1. Select the code you want to modify in the editor
  2. Press Cmd+K (macOS) or Ctrl+K (Windows/Linux)
  3. A small prompt appears near your selection
  4. Type your instruction (e.g., “add error handling”, “convert to TypeScript”, “optimize performance”)
  5. Press Enter to generate the change
  6. Review the diff and accept or reject
The inline editor is ideal for:
  • Adding error handling to a function
  • Converting code to use different patterns
  • Adding TypeScript types to JavaScript code
  • Refactoring small sections of code
  • Adding comments or documentation

​
Reviewing Changes

When the AI modifies your files, changes appear as diffs showing exactly what was added, modified, or removed. This gives you full visibility and control over every change.

​
Diff View

Changes are displayed with:
  • Green highlighting for additions
  • Red highlighting for deletions
  • Line numbers showing where changes occur

​
Accept and Reject

Each change can be individually accepted or rejected:
ActionmacOSWindows/Linux
Accept ChangeCmd+EnterCtrl+Enter
Reject ChangeCmd+BackspaceCtrl+Backspace
Next ChangeCmd+]Ctrl+]
Previous ChangeCmd+[Ctrl+[
Accept AllCmd+Shift+EnterCtrl+Shift+Enter
Reject AllCmd+Shift+BackspaceCtrl+Shift+Backspace

​
Checkpoints

The AI automatically creates checkpoints as it works, capturing the state of your files at each step. If you need to undo changes, you can revert to any previous checkpoint without losing your conversation history.

​
Tips for Better Results

Use Gather mode first for unfamiliar code - Before making changes to code you don’t fully understand, use Gather mode to explore and learn. This gives you context that helps you write better prompts when you switch to Agent mode. Start with Plan mode for complex tasks - For significant features or refactoring efforts, Plan mode helps you and the AI align on the approach before any code is written. You can catch misunderstandings early. Reference specific files - Using @ to reference files gives the AI precise context. This is more effective than describing files in words. Break large tasks into smaller requests - While Agent mode can handle complex multi-step tasks, breaking them into smaller pieces makes it easier to review changes and catch issues early. Review changes before committing - Always check your git diff before committing AI-generated changes. The AI is powerful but not perfect, and a quick review catches potential issues.