Defining Context

A. Using Workspace Scope

Tabnine defines a scope of context for your prompts with 1) designated files, 2) recent chat, 3) the open project, and more. This makes for higher-quality, context-aware completions. Used carelessly though, it can introduce noise or confusion.

This allows you to use to make:

1. Code-specific suggestions

2. Direct references to specific files

3. Implement project-specific changes

Example Prompt:

"Update the validate_user() function in this file to use the is_email_valid() method from utils/validators.py."

1. When to Turn Off or Broaden Scope

There are times you would want to be less narrow with scope so as not to limit the possibilities prompts elicit from the model:

1. Isolated examples or very specific code snippets might not benefit from the overly specific context of your project materials.

2. When restarting a conversation with the model, as in you might think a clean slate is necessary to prompt new material

3. You need to debug an issue and want to do this independent of “context interference.”

Example Scenario:

If you prompt:

“Write a Python function that sorts a list of tuples,” but you have an unrelated file open that uses namedtuple, Tabnine might introduce concepts that weren’t intended for this task.

2. Known Limitations

Keep these limits in mind so you can be strategic with your prompt writing:

• Only two recently opened files are loaded into Tabnine’s context window.

• Large or unrelated files may crowd out more relevant content.

• Tabnine doesn’t infer relationships beyond what’s open—module-level understanding is shallow.

• Implicit dependencies (e.g., database connections, environment variables) won’t be loaded unless referenced directly.

• Non-code files (e.g., config files, markdown) are usually excluded unless explicitly referenced in a prompt.

B. Starting a Fresh Conversation

During a thread/conversation Tabnine Chat contextualizes prior messages and local code context between prompts. This can help with continuity, but over time, context drift might interfere with making relevant responses. Given that, you should know when to give up on the thread and start a new one.

1. Signs Context Has Drifted

• The assistant misinterprets repeated prompts.

• It includes functions, files, or examples that you haven't recently referenced.

• Follow-ups degrade in relevance or quality.

• You find yourself saying, "Forget what I said before..." too often.

• Tabnine keeps pulling in old variable names, functions, or logic.

• It re-references things several prompts after you had successfully commanded it to ignore them

2. How to Reset Focus Cleanly

• Click "New Conversation" above the chat window or hit the cycling symbol in the upper right-hand corner.

• Close unrelated or noisy files in your IDE.

• Clearly reintroduce what you want in your new prompt.

Example:

"Let's start with a blank slate. Write a standalone function to normalize an array of numbers."

Tabnine will drop prior context and base its reply solely on this new input and current file state.

Navigating Chat History & Memory

While Tabnine retains a short-term working memory of your session, it does not retain long-term history. However, recent interactions prior to the current conversation can strongly bias outputs, sometimes in ways that are unhelpful.

Agent vs. Pure Chat

When you use Tabnine in your IDE, you’re not just chatting — you’re guiding an agent that operates over your project. Chat history shapes how it reasons. Additionally, remember that open files and repos shape what it can inspect and change. With that in mind, write prompts as if you’re giving standing instructions to a collaborator who’s working inside your repo.

A. When Forgetting Fails

Even though you explicitly told Tabnine to forget something, the model might see it as a strong suggestion or weigh that previous moment in the thread less in considering later responses in the conversation.

• You've explicitly told it to ignore previous input, but it still references earlier code or examples.

• Tabnine generates conflicting or contradictory code.

• It uses outdated context (e.g., old versions of functions).

B. Prompting Defensively

• Avoid ambiguous pronouns like "that" or "it." Instead, use "this function" or "the method in "utils.py." Be extremely deliberate and leave little to nothing unsaid. This also applies to specific code, specific open files, and other resources.

• Occasionally reintroduce your assumptions: e.g., "Assume we are working with a Flask app."

Note: Think about teaching a person the same topic. If you overload someone with information, they are more likely to forget minor points. Despite expecting an LLM to be more efficient, assume it is not and you can fall back on typical human-to-human conversational interactions.

C. RE-Iterate

• Reiterate what you’re trying to achieve. In other words, reinforce your intent: e.g., "Only show the SQL query. Don't explain it."

• Use "New Conversation" liberally when switching tasks or codebases.

Note: Think of this in the way you would think about containers in cloud apps. Instead of introducing everything in a single monolith, you would break up an app’s functions into contained modules where code is easier to manage and change later.

By managing memory expectations and explicitly controlling context, you reduce noise and get more reliable completions.