Development Environments for Developer Advocates

Developer Advocates work with different types of platforms, editors and IDEs, including AI-native workflows using the GitLab Duo Agent Platform. This page compiles best practices and useful tips to help optimize developer advocacy-related setups.

Resources

Start in the GitLab Duo Agent Platformdocumentation and read on for IDEs, CLI and extensibility and customization with MCP, custom rules, etc.

For architecture insights, review the architecture design document.

The GitLab Duo Agent Platform launch support issue - DevRel (internal) collects product/engineering updates, GTM and content strategies, and use case development.

IDEs

Developer Advocates can use different IDEs depending on their projects and content requirements. It is key to understand the IDE capabilities and use cases, put them into focus for content requests, and diversify usage for different audiences.

AI and GitLab Duo in IDEs

GitLab Duo and the GitLab Duo Agent Platform are integrated as IDE extensions/plugins.

Visual Studio Code

Visual Studio Code (short: VS Code) supports a variety of programming languages and development tool integrations through its marketplace.

GitLab Duo can be integrated through the GitLab Workflow extension in the VS Code marketplace.

Note

Review the internal guide for Dev Environments after completing the initial setup.

VS Code, light theme, with Duo Agentic Chat in the right panel. Editor shows diff view after agentic edits.

Tips and best practices for VS Code

  1. Learn and practice frequently used keyboard shortcuts for VS Code.
    • Command palette: cmd shift p on macOS or ctrl shift p on Windows/Linux.
    • Settings: cmd , on macOS or ctrl , on Windows/Linux.
    • Tip: You can also ask GitLab Duo Chat, or Claude for help.
  2. Open local Git repositories or directories using the code . shortcut from the terminal. This simplifies the workflow of editing/debugging code when you need to switch contexts between GitLab UI, VS Code and terminal.
  3. Open a terminal in VS Code (shortcut: cmd j on macOS, or cmd shift p and search for terminal). This allows starting background tasks like running servers, compilers, Ansible playbooks, etc. while editing code and avoids context switching between different windows.
  1. Enable auto-save while editing. This avoids data loss or missing Git commit data when writing your code.
    • UI: Open the settings by clicking the gear icon in the bottom left corner (shortcut: cmd , on macOS). Search for auto save.
    • VS Code settings.json: Add a new key/value for "files.autoSave": "afterDelay".
  2. Enable word-wrap by default. This makes long lines readable without horizontal scrolling.
    • UI: Open the settings by clicking the gear icon in the bottom left corner (shortcut: cmd , on macOS). Search for word wrap.
    • VS Code settings.json: Add a new key/value for "editor.wordWrap": "on".
  3. Install extensions you need regularly, and only use trusted sources.
    • Review the maintained list in @dnsmichi’s dotfiles project
    • You can install extensions on the CLI with code --install-extension. Example code --install-extension gitlab.gitlab-workflow.

Demo settings: Profiles and themes in VS Code

The default profile in VS Code uses a dark theme.

"workbench.colorTheme": "Default Dark Modern",

The light theme works better on in-person event projectors, and can help with demo recordings, too.

"workbench.colorTheme": "Default Light Modern",

It is recommended to create multiple profiles to manage different themes, and extensions installed, for example Default and Light theme for demos.

For required demo recording settings, review the video guidelines handbook.

Move Chat to the right panel

By default, the Chat panel is on the left side of the VS Code UI. This might interfere with file trees in the explorer and Git commits, which are also located on the left.

In order to move the Chat to the right sidebar:

  1. Open the Secondary Side bar with the icon on upper right corner.
  2. Drag the Chat icon (for example, Duo Chat) and drop it to the right sidebar.
  3. You can use multiple chat panels in parallel.

@dnsmichi uses this setup by default.

Enable additional languages for GitLab Duo Code Suggestions

  1. Choose between two paths:

    • UI: Open the settings by clicking the gear icon in the bottom left corner. Search for gitlab.duoCodeSuggestions.
    • VS Code settings.json: Press cmd shift p on macOS to open the command palette, and search for settings.json. Add/Modify the entry for "gitlab.duoCodeSuggestions.additionalLanguages" with an array of strings as value.

  2. Add markdown to the array when you want to see more code suggestions when editing your README.md file.

    • @dnsmichi is confident with the quality and the relevance of the following languages in settings.json (development test cycle: 1 year+):
    {
    "gitlab.duoCodeSuggestions.additionalLanguages": [
        "powershell",
        "yaml",
        "ansible",
        "perl",
        "dockerfile",
        "markdown",
        "json"
    ],
}

  3. It is important for Code Suggestions to have proper context: Open more tabs that are relevant to your current task, as those will be used for context.

A full VS Code settings.json example is located in @dnsmichi’s dotfiles project.

Debug VS Code extensions and GitLab Duo Agent Platform

An example use case: GitLab Duo Agentic Chat provides an MCP integration, and we want to verify that the MCP server is started and consumes the additional AI Context.

Need-to-know: The GitLab Language Server powers the backend across IDE extensions for GitLab, and handles the MCP integration for GitLab Duo Agentic Chat.

  1. You can debug extensions using the Output view in VS Code.
  2. Steps to debug:
    • Open the command palette with cmd shift p (macOS) and search for View: toggle Output.
    • Select GitLab Language Server in the Output view dropdown (next to Filter).
    • This view streams the extension log on the terminal. Trigger a UI action with GitLab Duo, and observe if the client sends the correct data.
  3. You can use the Filter form to search/filter the output, for example mcp to isolate entries related to the MCP integration.
  4. Optional: Increase the log verbosity to debug:
    • Open the settings by clicking the gear icon in the bottom left corner (shortcut: cmd , on macOS). Search for GitLab or gitlab in the settings tree.
    • Tick the GitLab: Debug checkbox and restart VS Code.

GitLab Duo Agentic Chat will also spawm terminals to run commands. If the execution is blocked or runs infinitely, investigate whether to disable terminal integrations like Oh-My-ZSH or Powerlevel10k.

JetBrains IDEs

Developer Advocates can access JetBrains IDEs for different purposes and use cases:

  • IntelliJ IDEA Ultimate (Java, Kotlin, Scala)
  • PyCharm (Python, Django)
  • GoLand (Go)
  • DataGrip (SQL, Databases)
  • RubyMine (Ruby, Rails)
  • PhpStorm (PHP)
  • WebStorm (JavaScript, TypeScript, HTML/CSS)
  • Rider (C#, .NET)
  • CLion (C, C++)
  • Android Studio (Android development)

IntelliJ IDEA also supports plugins for other languages, the availability depends on the subscription tier (Ultimate vs Community).

GitLab Duo can be integrated using the GitLab Duo plugin in the JetBrains marketplace.

Note

Review the internal guide for Dev Environments after completing the initial setup.

JetBrains IntelliJ IDEA with Duo Agentic Chat, modernizing Java 8 to 21, editor shows diff view from agentic edits.

Tips and best practices for JetBrains IDEs

  1. Review the available IDE licenses, and eventually create an Access Request for additional permanent IDE licenses.
  2. Read the setup and configuration guide and install the JetBrains Toolbox to manage individual IDEs and their updates.
    • Optional tip: By default, the toolbox keeps older installed versions. If this behavior causes problems with storage consumption, disable the setting in Tools > Keep previous versions to enable instant rollback.
    • JetBrains IDEs can migrate/import configuration from existing setups. This is convenient to install/configure the GitLab Duo plugin once, and import it into another JetBrains IDE.
  3. GitLab Duo Agentic Chat will also spawm terminals to run commands. If the execution is blocked or runs infinitely, investigate whether to disable terminal integrations like Oh-My-ZSH or Powerlevel10k.

Demo settings: Appearance in JetBrains IDEs

The default profile in JetBrains IDEs uses a dark theme. In order to switch to a light theme, navigate into Settings > Appearance & Behavior > Appearance and select Light with Light Header.

The Zoom dropdown can be changed to 125% for increased details in talk live demos.

For required demo recording settings, review the video guidelines handbook.

MS Visual Studio

Note: Needs access to a Windows and Visual Studio license, and requires additional security review.

Status: Research. Todos are tracked in this internal issue.

GitLab Duo can be integrated using the GitLab extension in the Visual Studio marketplace.

Note

Review the internal guide for Dev Environments after completing the initial setup.

Eclipse

GitLab Duo can be integrated using the GitLab extension in the Eclipse marketplace.

neovim

Tip: Start a new neovim configuration using a fork of kickstart.nvim to bootstrap and optimize your neovim experience.

GitLab Duo can be integrated using a neovim plugin.

CLI

GitLab Duo CLI

The GitLab Duo CLI provides access to GitLab Duo Agent Platform on the terminal.

Requirements:

  1. Install NodeJS 22+, for example, using mise
  2. Create a Personal Access Token with api scope.
  3. Install the CLI.
  4. Run the CLI to start the configuration dialogue.
mise install node@22

npm i -g @gitlab/duo-cli

duo

Usage examples:

Which tools are available?

What is this repository about

Which issues need my attention

Help me implement issue 15

The pipelines in MR 23 fail. Please fix them.

The CLI uses the GitLab LSP to communicate with the AIGW and DAP services, and therefore the CLI is developed inside gitlab-lsp.

Follow the product epic for functionality and roadmap updates, and add feedback into the Duo CLI Feedback & Dogfooding epic.

Extensibility and Customization

Custom Rules

Consider addding custom rules by default to every new or existing Developer Advocacy project.

  1. Custom rules for Agentic Chat.
  2. Custom review instructions for Code Review Agent.
  3. System prompt for custom agents in the AI Catalog.

Example projects:

MCP Clients

Refer to the GitLab MCP Clients documentation on how to integrate MCP clients into IDEs.

Internal research issue: DAP MCP use case testing - DevRel

MCP Server

Refer to the GitLab MCP Server documentation for setup and configuration in AI tools and IDEs.

Knowledge Graph

Follow the Knowledge Graph documentation for setup and integration steps.

The GitLab Knowledge Graph First Iteration product epic tracks the development and feature roadmap.

Self-hosted models for Duo Agent Platform

Access to supported self-hosted models requires access to the engineering test infrastructure. Review the self-hosted models research in FY26 (internal) for DRIs, options and ideas.

GitLab Duo Agent Platform use cases

Developer Advocates use case prompts

Use these prompts with GitLab Duo Agentic Chat in IDEs, and the CLI:

Demo Environment Management

  • “Create a new demo project setup guide for technology/feature”
  • “Document the prerequisites for this demo environment”
  • “Generate a troubleshooting guide for common demo setup issues”
  • “Create a quick start script for setting up demo environment”

Demo Repository & Code

  • “Create a sample application demonstrating GitLab feature”
  • “Add comprehensive README with setup instructions for this demo”
  • “Generate example CI/CD pipeline for language/framework demo”
  • “Create a demo showcasing feature integration with technology”

Content Creation Support

  • “Extract code snippets from this demo for a blog post”
  • “Generate speaker notes for demoing this feature”
  • “Create a step-by-step tutorial from this demo repository”
  • “Suggest improvements to make this demo more engaging”

Environment Documentation

  • “Document the tools and versions used in this environment”
  • “Create a comparison table of different setup approaches”
  • “Generate installation instructions for OS/platform”
  • “Document environment variables and configuration needed”

Demo Maintenance

  • “Check if this demo uses deprecated GitLab features”
  • “Update this demo to use the latest framework version”
  • “Verify all demo links and references are still valid”
  • “Test if this demo still works with current GitLab version”

Workshop & Presentation Prep

  • “Create a workshop outline based on this demo”
  • “Generate talking points for presenting this feature”
  • “Build a hands-on exercise from this example”
  • “Create a cheat sheet for workshop participants”

Integration Examples

  • “Show how to integrate tool with GitLab in this demo”
  • “Create examples for all feature configuration options”
  • “Generate sample webhook payloads for testing”
  • “Document API usage examples for this integration”

Documentation & Content Management

  • “Review this page for broken links and outdated information”
  • “Check if this documentation follows the handbook style guide”
  • “Find all pages that mention topic and summarize them”
  • “Suggest improvements to make this page more accessible”

Repository Navigation & Understanding

  • “Show me the most recently updated pages in directory”
  • “What are the main sections of this handbook?”
  • “Find documentation about [specific process or policy]”
  • “Who are the main contributors to directory/file?”

Maintenance & Quality

  • “Find pages that haven’t been updated in over 6 months”
  • “Check for inconsistent formatting across similar pages”
  • “Identify duplicate or overlapping content”
  • “Review recent merge requests for this section”

Workflow Automation

  • “Create a new handbook page for topic following the template”
  • “Update all references to [old term] with [new term]”
  • “Generate a changelog for recent updates to section”
  • “Create an issue for outdated content in directory”

Collaboration

  • “Summarize recent discussions on topic from issues and MRs”
  • “Who should I ask about [specific handbook section]?”
  • “Show me open merge requests that need review”
  • “Find related work items for this documentation update”

CI/CD Specific

  • “Convert this YAML anchor to use extends instead”
  • “Add proper rules to this CI job”
  • “Optimize the pipeline configuration for faster builds”

Development

mise for managing language runtimes

mise is a polyglot version manager that helps manage different language runtimes and tools. It is used in the GitLab Development Kit (GDK) and GitLab handbook to manage Node.js, Ruby, Go, and other dependencies.

Developer Advocates can use mise to:

  1. Manage multiple language versions: Easily switch between different versions of Node.js, Python, Ruby, Go, etc., required for various projects or demos.

    mise use node@22
mise use node@24

  2. Ensure consistent environments: Define project-specific tool versions in a .mise.toml or .tool-versions file, ensuring that all team members (or your different projects) use the same environment.

    # .mise.toml example
[tools]
node = "25"
python = "3.14"
go = "1.25"

  3. Simplify tool installation: Install and manage tools like npm, yarn, pip, go without system-wide interference.

    mise install node@25
mise install python@3.14

  4. Integrate with IDEs: Ensure that IDEs like VS Code or JetBrains IDEs pick up the correct tool versions managed by mise by configuring the shell environment.

Tips and best practices for mise

  1. Install mise: Follow the official installation guide.

  2. Configure your shell: Add eval "$(mise activate)" to your shell configuration file (e.g., .zshrc, .bashrc).

  3. Use .mise.toml or .tool-versions: For project-specific versions, create one of these files in your project root. mise will automatically detect and activate the specified versions when you navigate into the directory.

  4. Global versions: Set global default versions for tools using mise global <tool>@<version>.

    mise global node@22

  5. Check current versions: Use mise current to see which tool versions are active in your current directory.

  6. List installed versions: Use mise ls to see all installed versions of a tool.

  7. Update tools: Keep your tools up-to-date with mise upgrade.

For more advanced usage and configuration, refer to the mise documentation.

mise environments in GitLab development

Remote Development Workspaces

Workspaces offer cloud development environments, running on Developer Relations Cloud Resources.

Status: Inactive. Currently, there is no infrastructure maintainer. The following documentation exists for historical reference in the future.

The remote-development sub group has an agent for Kubernetes installed, which is documented in the agent-kubernetes-gke project. This includes troubleshooting when the agent becomes unresponsive, and workspaces are not created.

Resources:

  1. The Kubernetes cluster da-remote-development-1 needs to be running in GKE. Current resources: 3 nodes. Total 6 vCPU, 12 GB memory.
  2. The domain remote-dev.dev has been purchased through the Google DNS service and points to the Kubernetes cluster’s public IP.
  3. The TLS certificates have been generated manually with Let’s Encrypt and need to be renewed quarterly (2023-08-15), following the documentation steps.

Learning resources

Team member examples

Talks and demos highlighting Dev Environments

Review the Developer Advocacy content library and the following resources:

  1. Learning AI 101: Practical Foundations for Developers - 2025-06, Open Source @ Siemens
  2. Efficient DevSecOps workflows with a little help from AI - 2024-12, GitLab DACH Roadshow FY25
Last modified December 1, 2025: Fix image path again for DA dev envs (d4e4ee9e)
View page source - Edit this page - please contribute. Creative Commons License