1. You are here:
2. GitLab Direction
3. Product Stage Vision - Create
4. Group Direction - Code Creation
5. Category Direction - Code Suggestions

On this page

• Code Suggestions
  • Introduction and how you can help
  • Overview
    • Vision
    • Mission
    • Strategy and Themes
      • Themes
      • Strategy
      • Target Audience
      • Challenges to Address
    • 1-year plan
    • What we recently completed
    • What is Not Planned Right Now
  • Key Features
    • Maturity Plan
    • User success metrics
  • Competitive Landscape

Code Suggestions

Stage	Create
Group	Code Creation
Maturity	minimal
Content Last Reviewed	2023-09-22

Introduction and how you can help

Thanks for visiting this category direction page on Code suggestions in GitLab. This page belongs to the Code Creation group of the Create stage and is maintained by Kevin Chu (kchu at gitlab dot com).

Overview

Code suggestion systems use Generative AI to suggest relevant code snippets and autocomplete code while software developers are writing code. These systems aim to boost programmer productivity and reduce time spent on rote coding tasks. Some key points about AI code suggestion systems:

• Code suggestion often uses [large language models], trained on huge data sets, such as open source code repositories or other scraped content, to repeatedly predict the next token or code snippet, provided a prompt.
• Code suggestions is inclusive of code completion and code generation, which includes turning natural language prompts into code suggestions
• Code suggestions should empower developers to focus on higher logic and architecture rather than routine coding. Reduces simple errors.
• Limitations and risks of using AI code suggestions include:
  • Bias perpetuation - GenAI may inadvertently amplify biases found in the training data
  • Quality control - Risk generating incorrect or faulty code without proper evaluation
  • Legal - Copyright, attribution, and licensing for all AI generated content needs to be thought through.
• Code suggestion typically is integrated with IDEs

Vision

In the long run, we intend to revolutionize the software development process through the integration of AI-assisted code suggestions, resulting in increased productivity, reduced errors, and improved overall software quality. Furthermore, we intend to enrich the experience by introducing NLP search in our WebIDE to help developers speed up the development process.

Mission

Strategy and Themes

Themes

Strategy

Target Audience

Initially, we are focused on traditional developer personas including:

1. Sasha (Software Developer)
2. Priyanka (Platform Engineer)
3. Simone (Software Engineer in Test)
4. Delaney (Development Team Lead)

In the future, we may expand to security personas to help write more secure code and review code for security vulnerabilities and fix them early in the software development lifecycle (SDLC), before you commit.

Challenges to Address

By implementing AI Assisted Code Suggestions in integrated development environments (IDEs), we intend to transform the software development lifecycle for our customers in the following ways:

1. Increased productivity: Empower Developers to write code faster and more efficiently, with code suggestions for code snippets and improvements in real time.
2. Reduced errors: Detect and suggest corrections for errors as they occur, reducing the time and effort spent on debugging.
3. Improved code quality: Suggest refactoring and best practices, leading to more maintainable and performant code.
4. More efficient collaboration: Developers should be able to share and reuse code snippets with their team members, leading to more efficient collaboration.
5. Access to a broader range of knowledge: Suggest code snippets and improvements across a wide range of programming languages and platforms, providing developers access to a broader range of knowledge.

Overall, the integration of AI Assisted Code Suggestions should greatly improve the efficiency, quality, and speed of the software development process. We are working through several constraints such as legal, and data privacy concerns in order to make the best experience available for our customers.

1-year plan

With the Beta release, we are now focused on providing functionalities like code completion, code recommendations as well as code fillers to improve the quality of the suggestions by Q2, 2023. With that, We plan on extending our language support to 13 programming languages. Currently, code suggestions are available to use in Visual Studio Code via GitLab workflow extensions. We will soon add support for the new GitLab WebIDE. We are actively adding monitoring and infrastructure support to better scale and optimize code suggestions. We will continue iterating on early beta user feedback and enhance the underlying models, the inference backend, and extend support for other IDEs.

We want code suggestions to feel natural and not get in the way, we will be improving the UX for code suggestions experience to ensure developers enjoy a seamless experience as they code. To improve the quality of the code suggestions, We are exploring merging models via request routing to have multiple specialized models handling the request types that are best suited to handle. we are also exploring code suggestions for GitLab-ci.yml files for MVC - An additional use case that can help us pave the way for future training on customer code and explore test harness generation to help developers automate the creation of tests by generating them through code suggestions.

Smart code completion to optimize code Summary: How might we ensure developers can write code more quickly and precisely, which completes code snippets based on context? This may lead to fewer mistakes and more effective development.

1. Autocomplete: Offers code completion suggestions based on what has already been written. It can suggest the next word, function, or parameter to speed up coding.
2. Code Snippets: Suggests prewritten code fragments that can be placed into the current code to save time and effort. The code editor may offer these snippets, or they may be user-defined.
3. Predictive Analysis with real-time debugging: To expedite development, examine the written code and suggest the following logical step or functions and provide real-time suggestions for enhancements and debugging suggestions.
4. Variable naming: Suggest variable names that are more relevant and descriptive so that your code is simpler to read and comprehend.
5. Code commenting: Consider adding comments to your code to clarify its purpose and make it simpler for others to read, comprehend, and maintain.
6. Code documentation: Automatically generate documentation to make it simpler for peers to use and comprehend your code.
7. Code completion with NL: Based on the natural language text context, suggest code recommendations to make coding simpler and faster.
8. Code reuse: Suggest repurposing previously created code to reduce duplication and increase code efficiency.
9. Error handling: Provide recommendations for how to deal with errors in your code to keep it stable and prevent crashes.

What we recently completed

What is Not Planned Right Now

Currently, we are not developing a fully original GitLab-trained model, however, that is something we may consider in the future. For now, we will focus on open-source code generation models.

Continuous integration and deployment Summary: How might we facilitate continuous integration and deployment by identifying code changes that could cause potential conflicts? This will enable developers to resolve issues quickly and roll out production code faster.

1. Code Quality Analysis: Examine the codebase to find problems like duplicate code, code smells, and other code quality problems. This aids programmers in enhancing code quality and lowering technical debt.
2. Code Review Assistant: Provide suggestions for review script changes to flagging out potential problems and give suggestions for enhancements. This can save time for developers by you can make it easier to find errors before they cause issues.
3. Continuous Testing: Automate testing procedures and determine when tests should be rerun based on code changes. This assures that the code is always rigorously tested and aids teams in identifying problems early in the development process.
4. Code summarization: This feature summarizes code by extracting the most important information from it. This helps the programmer to understand code more quickly and easily.
5. Code Style Suggestions: Makes formatting and style recommendations based on best practices and guidelines, which raises the level of uniformity and quality of the code
6. Code search: This feature allows the programmer to search for code based on natural language queries. The search results can be sorted and filtered based on relevance, popularity, or other criteria.

To Automatic bug detection and patching

1. Coming soon

Key Features

Smart code completion

1. Support faster and more accurate code completion without analyzing the context in the file you are editing or file type.
2. Ability to pick from various suggestions including context allowing for developers to direct recommendations towards a specific solution more easily.
3. Generate suggestions for APIs and frameworks allowing developers to fill in low-value common boilerplate code.

4. **Ability to turn suggestions on

   off as needed** extending greater control over the developer IDE experience.

Test case generation and automation

1. Ability to generate Code Completions for gitlab-ci.yml files.

Programming in natural language

1. Generate code suggestions from plain text allowing suggestions to take direction and have a greater context of developer intention.

Maturity Plan

This category is currently at minimal maturity.

User success metrics

We plan to measure the success of this category based on the following metrics:

• Developer cycle time - Code Suggestions may make developers more efficient and we believe help reduce the number of bugs, security vulnerabilities, and stylistic issues improving developer cycle time.
• Time to merge - With more efficient coding, merge requests will merge faster with less review time and back and forth between reviewers and authors.
• Developer SUS - Improved coding experience may directly improve the developer's usability and satisfaction with the GitLab development experience.

Competitive Landscape

Please see the content in our internal handbook