• Use Code Suggestions
• View multiple code suggestions
• Code completion and generation
  • Best practices for code generation
• Advanced Context
  • Advanced Context supported languages
  • Open tabs as context
    • Enable open tabs as context
    • Use open tabs as context
  • Inference window context
• Truncation of file content
• Output length
• Accuracy of results
• Response time
  • Streaming
  • Direct and indirect connections
    • Configure direct or indirect connections
• Feedback

Code Suggestions

Use GitLab Duo Code Suggestions to write code more efficiently by using generative AI to suggest code while you’re developing.

Before you start using Code Suggestions, decide if you want to use the default GitLab-hosted LLM to manage Code Suggestions requests, or deploy a self-hosted model. Self-hosted models maximize security and privacy by making sure nothing is sent to an external model.

View a click-through demo.

Use Code Suggestions

Prerequisites:

• You must have set up Code Suggestions.

To use Code Suggestions:

1. Open your Git project in a supported IDE.
2. Add the project as a remote of your local repository using git remote add.
3. Add your project directory, including the hidden .git/ folder, to your IDE workspace or project.

4. Author your code. As you type, suggestions are displayed. Code Suggestions provides code snippets or completes the current line, depending on the cursor position.

5. Describe the requirements in natural language. Code Suggestions generates functions and code snippets based on the context provided.

6. When you receive a suggestion, you can do any of the following:
   • To accept a suggestion, press Tab.
   • To accept a partial suggestion, press either Control+Right arrow or Command+Right arrow.
   • To reject a suggestion, press Esc.
   • To ignore a suggestion, keep typing as you usually would.

View multiple code suggestions

For a code completion suggestion in VS Code, multiple suggestion options might be available. To view all available suggestions:

1. Hover over the code completion suggestion.
2. Scroll through the alternatives. Either:
   • Use keyboard shortcuts:
     • On a Mac, press Option + ] to view the next suggestion, and Option + [ to view the previous suggestions.
     • On Windows, press Alt + ] to view the next suggestion, and Alt + [ to view the previous suggestions.
   • On the dialog that’s displayed, select the right or left arrow to see next or previous options.
3. Press Tab to apply the suggestion you prefer.

Code completion and generation

Code Suggestions uses code completion and code generation:

Code Suggestions always uses both of these features. You cannot use only code generation or only code completion.

View a code completion vs. code generation comparison demo.

Best practices for code generation

To get the best results from code generation:

• Be as specific as possible while remaining concise.
• State the outcome you want to generate (for example, a function) and provide details on what you want to achieve.
• Add additional information, like the framework or library you want to use.
• Add a space or new line after each comment. This space tells the code generator that you have completed your instructions.
• In GitLab 17.2 and later, when the advanced_context_resolver and code_suggestions_context feature flags are enabled, open related files in other tabs to expand the inference window context.

For example, to create a Python web service with some specific requirements, you might write something like:

# Create a web service using Tornado that allows a user to sign in, run a security scan, and review the scan results.
# Each action (sign in, run a scan, and review results) should be its own resource in the web service
...

AI is non-deterministic, so you may not get the same suggestion every time with the same input. To generate quality code, write clear, descriptive, specific tasks.

For use cases and best practices, follow the GitLab Duo examples documentation.

Advanced Context

When using Code Suggestions, the Advanced Context feature searches in the background to find and include relevant context from across a user’s repository.

For more information, see the Advanced Context Resolver project epic.

Advanced Context supported languages

The Advanced Context feature supports these languages:

• Code completion: all configured languages.
• Code generation:
  • Go
  • Java
  • JavaScript
  • Kotlin
  • Python
  • Ruby
  • Rust
  • TypeScript (.ts and .tsx files)
  • Vue
  • YAML

Open tabs as context

To get more accurate and relevant results from Code Suggestions and code generation, you can use the contents of the files open in tabs in your IDE. Similar to prompt engineering, these files give GitLab Duo more information about the standards and practices in your code project.

Open tabs as context is part of the Advanced Context feature.

Enable open tabs as context

By default, Code Suggestions uses the open files in your IDE for context when making suggestions.

Prerequisites:

• You must have GitLab 17.2 or later. Earlier GitLab versions that support Code Suggestions cannot weigh the content of open tabs more heavily than other files in your project.
• GitLab Duo Code Suggestions must be enabled for your project.
• Use a supported code language:
  • Code completion: All configured languages.
  • Code generation: Go, Java, JavaScript, Kotlin, Python, Ruby, Rust, TypeScript (.ts and .tsx files), Vue, and YAML.
• For Visual Studio Code, you must have GitLab Workflow extension version 4.14.2 or later.

To confirm that open tabs are used as context:

Use open tabs as context

Open the files you want to provide for context:

• Open tabs uses the most recently opened or changed files.
• If you do not want a file used as additional context, close that file.

When you start working in a file, GitLab Duo uses your open files as extra context, within truncation limits.

You can adjust your code generation results by adding code comments to your file that explain what you want to build. Code generation treats your code comments like chat. Your code comments update the user_instruction, and then improve the next results you receive.

To learn about the code that builds the prompt, see these files:

• Code generation: ee/lib/api/code_suggestions.rb in the gitlab repository.
• Code completion: ai_gateway/code_suggestions/processing/completions.py in the modelops repository.

Inference window context

Code Suggestions inferences against:

• The currently opened file.
• The content before and after the cursor.
• The filename and extension.
• In GitLab 17.2 and later when the advanced_context_resolver and code_suggestions_context feature flags are enabled.
  • Files opened in other tabs.
  • User instructions.

For more information on possible future context expansion to improve the quality of suggestions, see epic 11669.

Truncation of file content

Because of LLM limits and performance reasons, the content of the currently opened file is truncated:

• For code completion:
  • In GitLab 17.5 and earlier, to 2,048 tokens (roughly 8,192 characters).
  • In GitLab 17.6 and later, to 32,000 tokens (roughly 128,000 characters).
• For code generation: to 142,856 tokens (roughly 500,000 characters).

Content above the cursor is prioritized over content below the cursor. The content above the cursor is truncated from the left side, and content below the cursor is truncated from the right side. These numbers represent the maximum input context size for Code Suggestions.

Output length

Because of LLM limits and for performance reasons, the output of Code Suggestions is limited:

• For code completion: to 64 tokens (roughly 256 characters).
• For code generation: to 2048 tokens (roughly 7168 characters).

Accuracy of results

We are continuing to work on the accuracy of overall generated content. However, Code Suggestions might generate suggestions that are:

• Irrelevant.
• Incomplete.
• Results in failed pipelines.
• Potentially insecure.
• Offensive or insensitive.

When using Code Suggestions, code review best practice still applies.

Response time

Code Suggestions is powered by a generative AI model.

• For code completion, suggestions are usually low latency and take less than one second.
• For code generation, algorithms or large code blocks might take more than five seconds to generate.

Your personal access token enables a secure API connection to GitLab.com or to your GitLab instance. This API connection securely transmits a context window from your IDE/editor to the GitLab AI gateway, a GitLab hosted service. The gateway calls the large language model APIs, and then the generated suggestion is transmitted back to your IDE/editor.

Streaming

Streaming of Code Generation responses is supported in VS Code, leading to faster average response times. Other supported IDEs offer slower response times and will return the generated code in a single block.

Direct and indirect connections

By default, code completion requests are sent from the IDE directly to the AI gateway to minimize the latency. For this direct connection to work, the IDE must be able to connect to https://cloud.gitlab.com:443. If this is not possible (for example, because of network restrictions), you can disable direct connections for all users. If you do this, code completion requests are sent indirectly through the GitLab self-managed instance, which in turn sends the requests to the AI gateway. This might result in your requests having higher latency.

Configure direct or indirect connections

Prerequisites:

• You must be an administrator for the GitLab self-managed instance.

Feedback

Provide feedback about your Code Suggestions experience in issue 435783.