How I use VS Code with AL and Business Central

On popular demand, this video is a tour of how I use Visual Studio Code. Check out the video:

https://youtu.be/23KS9dBSAwY

In this video, Erik walks through his personal Visual Studio Code setup for AL development with Business Central. Rather than a feature showcase of every possible extension, this is a practical, opinionated guide from someone who values simplicity and keyboard efficiency. Erik covers how he launches VS Code, the keyboard shortcuts he uses constantly, which extensions he has installed (and why he keeps the list short), and how the AL compiler works behind the scenes.

Launching VS Code from the Command Line

Erik is a self-described lover of the command line, and that’s where his workflow begins. When he’s in a folder containing an AL project — identifiable by the presence of app.json, a .vscode folder, and AL source files — he launches VS Code with a simple command:

code .

The code command starts VS Code, and the dot (.) tells it to open the current directory. You could also specify a different folder path if needed, but if you’re already in the project folder, the dot is all you need. VS Code opens with the full project loaded and ready to go.

A typical AL project folder will contain files like these:

// app.json - The project manifest
{
  "id": "f02b9892-4c88-4903-bc7a-bfc4dea694e1",
  "name": "Video10",
  "publisher": "Default publisher",
  "version": "1.0.0.0",
  "dependencies": [
    {
      "id": "63ca2fa4-4f03-4f2b-a480-172fef340d3f",
      "publisher": "Microsoft",
      "name": "System Application",
      "version": "16.0.0.0"
    },
    {
      "id": "437dbf0e-84ff-417a-965d-ed2bb9650972",
      "publisher": "Microsoft",
      "name": "Base Application",
      "version": "16.0.0.0"
    }
  ],
  "platform": "16.0.0.0",
  "idRanges": [
    {
      "from": 50100,
      "to": 50149
    }
  ],
  "showMyCode": true,
  "runtime": "5.0"
}

The Three Panes and Essential Keyboard Shortcuts

Erik describes the VS Code screen layout as three things constantly fighting for space: the sidebar (file explorer, extensions, source control), the editor (the main attraction — “notepad on steroids”), and the bottom panel (output, terminal, problems). The two keyboard shortcuts he uses more than almost anything else are:

  • Ctrl+B — Toggles the sidebar (file explorer, extensions, etc.) open and closed
  • Ctrl+J — Toggles the bottom panel (output, terminal, problems) open and closed

These two shortcuts let you quickly reclaim screen real estate for your source code. Sometimes Erik hits both in quick succession to get a completely clean editor view, and other times he’ll keep one or the other open depending on the task.

Zooming In and Out

Since VS Code is an Electron app (essentially a web browser rendering your editor via Chromium), the standard browser zoom shortcuts work perfectly:

  • Ctrl+Plus — Zoom in
  • Ctrl+Minus — Zoom out

Erik uses this frequently — zooming in for distraction-free focus on a specific piece of code, and zooming out to see more context or when sharing his screen. It’s a simple trick but one that makes a real difference in day-to-day work.

Extensions: Less Is More

Erik is emphatic on this point: don’t install every AL or BC extension you can find. He’s seen developers with 30–40 extensions installed, not knowing which one does what. His approach is deliberately minimal — only 12 extensions total, and only a handful that he actively relies on for AL development.

The Essential: AL Language Extension

The single most important extension is the AL Language extension from Microsoft (for Dynamics 365 Business Central). This handles everything: compiling, deploying, debugging — all the core AL functionality. Erik stresses that in reality, this one extension is all you need. When you have it installed, you can do anything required for AL development.

Community AL Extensions

Beyond the official AL Language extension, Erik uses just two community AL extensions:

  1. AZ AL Dev Tools / AL Code Outline (by Andrzej Zwierzchowski) — Erik calls this a “treasure trove of good things.” One feature he highlights is the ability to click on an .app file (symbol file) and get a nice simple browser view of its contents. This extension has a dependency on Waldo’s CRS AL Language Extension, which is why that one also appears in Erik’s installed list.
  2. AL Code Actions (by David Feldhoff) — Primarily used for extracting selected code into a new procedure. It automatically figures out the required parameters, which is a huge time-saver during refactoring.

With the AL Language extension, AZ AL Dev Tools, and AL Code Actions, Erik considers himself fully productive in AL. Everything else is supplementary.

Other Installed Extensions

  • Dracula — A color theme that gives Erik’s editor its distinctive look
  • VS Code Counter / Code Counter — Provides file and line count statistics for a project, useful for getting a quick sense of project size
  • GitHub Copilot — The AI code assistant. Erik says he’s “still on the fence” and quite often turns it off. He’s configured it to only activate for C# and AL files, having gotten tired of unhelpful suggestions in text files and markdown.
  • GitLens — Enhances the built-in source control with branch visualization, history browsing, stash management, and easier merging
  • Paste Image — Used for writing his field guide book in Markdown within VS Code. It lets him paste screenshots directly into markdown, saving the image file and inserting the proper markdown syntax automatically.
  • XML Formatting Tool — For formatting XML files

A Word on Extension Performance

Erik points out that every extension has a startup cost, measured in milliseconds and visible in the extensions panel. If your VS Code suddenly feels slow, check which extensions are taking too long to start. There are no truly “free” extensions in terms of performance — even color schemes have some cost, though minimal.

The Command Palette: The Real Power of VS Code

While VS Code has a traditional menu bar, Erik rarely uses it. The real power lives in the Command Palette, accessed with:

  • Ctrl+Shift+P — Opens the Command Palette in command mode (note the > prefix)

The Command Palette has three modes depending on what you type:

  1. Command mode (with > prefix) — Search and execute any command, like AL: Download Symbols, AL: Publish, etc.
  2. Search mode (remove the >) — Search for files across your project
  3. Navigation mode (type : followed by a line number) — Jump directly to a specific line, e.g., :54 jumps to line 54

Frequently used commands already have dedicated keyboard shortcuts:

  • F5 — Publish with debugging
  • Ctrl+Shift+B — Build without publishing

How the AL Compiler Works in VS Code

This is one of the more illuminating parts of the video. Erik explains that the AL compiler is constantly compiling your code in the background. You don’t actually need to trigger a build — the compiler works as a service, similar to how Microsoft open-sourced Roslyn (the C# compiler) back around 2016–2018.

The compiler maintains a source tree and performs incremental compilations. When you change a single line, it determines the minimum amount of recompilation needed to stay up-to-date. The red squiggly errors you see in the editor aren’t pseudo-results or simple syntax highlighting — they’re actual compilation errors.

For example, if you introduce a bug in a file like this:

pageextension 50100 CustomerListExt extends "Customer List"
{
    trigger OnOpenPage();
    begin
        Message('App published: Hello world');
    end;
}

The compiler will immediately flag the error in the editor, and running Ctrl+Shift+B to do a full build will produce the same error in the output panel.

However, the incremental compiler can occasionally get out of sync, especially when:

  • Working on large projects
  • Switching Git branches
  • Copying files into the project folder from outside VS Code
  • Any operation that changes files without going through VS Code’s file watcher

The fix is straightforward — open the Command Palette and run Developer: Reload Window. This resets the environment, reloads all extensions, and forces a fresh compilation of the project.

Navigation and Search

Erik covers several navigation techniques he uses daily:

  • F12 — Go to Definition. Right-click on a symbol and select “Go to Definition,” or just press F12. This takes you to where that symbol is defined.
  • Find All References — Right-click and select “Find All References” for a smarter, context-aware search of where a symbol is used.
  • Ctrl+Shift+F — Global search across all files. Erik often uses this as a quick “find where used” alternative when Go to Definition or Find All References feels slow.
  • Ctrl+Shift+H — Global search and replace across all files. It’s the same tool as Ctrl+Shift+F, just with the replace field toggled on.

Other Handy Shortcuts

  • Ctrl+W — Close the current file/tab
  • Ctrl+Shift+T — Reopen a recently closed file (just like reopening a closed tab in a browser)
  • Ctrl+R — Open a list of recently used projects/folders for quick switching between apps

The Minimap

Erik keeps the minimap visible on the right side of the editor. He admits he doesn’t use it heavily, but finds it useful for spotting where errors are located in larger files. Since source code is primarily vertical, the minimap occupies horizontal space that isn’t as valuable, so the trade-off is worth it.

Settings and Configuration

VS Code settings are accessible through the settings UI (File > Preferences > Settings), where you can find extension-specific settings under the Extensions section. However, Erik notes that not all settings are exposed in the UI — some can only be configured by editing settings.json directly.

One notable setting Erik highlights is semantic highlighting for AL, which provides richer syntax coloring that distinguishes between parameters, variables, and other code elements. He also mentions configuring GitHub Copilot to only activate for specific languages:

// In settings.json - restrict Copilot to specific languages
"github.copilot.enable": {
    "al": true,
    "csharp": true,
    "markdown": false,
    "plaintext": false
}

A Sample AL Project

The project used in the video is a straightforward AL app with a page extension and a table definition. Here’s the table object as an example of typical AL source code you’d work with in this setup:

table 50100 "Awesome AZ demo"
{
    Caption = 'Awesome AZ demo';
    DataClassification = ToBeClassified;
    
    fields
    {
        field(1; "Key Field"; Code[20])
        {
            Caption = 'Key Field';
            DataClassification = SystemMetadata;
        }
        field(10; Name; Text[100])
        {
            Caption = 'Name';
            DataClassification = SystemMetadata;
        }
    }
    keys
    {
        key(PK; "Key Field")
        {
            Clustered = true;
        }
    }
}

Summary

Erik’s approach to VS Code for AL development can be distilled into a few key principles:

  1. Keep extensions minimal. The AL Language extension is all you truly need. Add AZ AL Dev Tools and AL Code Actions for productivity, but resist the urge to install everything.
  2. Learn the keyboard shortcuts. Ctrl+B, Ctrl+J, Ctrl+Shift+P, Ctrl+Shift+B, F5, Ctrl+R, F12 — these are the shortcuts that form the backbone of an efficient workflow.
  3. Use the Command Palette. It’s the single most powerful feature in VS Code. Learn to live in it.
  4. Understand the compiler. The AL compiler runs continuously in the background using incremental compilation. When it gets confused, Developer: Reload Window is your reset button.
  5. Keep your environment tidy. Every extension has a performance cost. Find the tools that add genuine value to your workflow and skip everything else.
Picture of hougaard

hougaard