DvlprLife.com – Follow the life of a Dynamics 365 Business Central Enthusiast, one post at a time.

May 26 2026

Weekly Review: Business Central AL Development – May 17–23, 2026

By Dvlpr in Weekly Review
May 26, 2026

Highlighting posts and resources from the Business Central development community — May 17–May 23, 2026

A week heavy on AI tooling and developer workflow, with a security wake-up call mixed in. Stefano Demiliani urges caution on VS Code extensions after a GitHub malware breach, Jeffrey Bulanadi adds an MCP layer to BC container management, and Torben Leth previews a near-autonomous work-item-to-PR pipeline ahead of BC TechDays. Javi Armesto reflects on working above the agentic harness, Gerardo Rentería configures global memory for VS Code agents, and Steven Renders reminds us BC release pauses are the norm.

Community Resources

Official Resources

GitHub Repositories

microsoft/BCApps – Repository for collaboration on Microsoft Dynamics 365 Business Central applications.
microsoft/BCTech – Business Central technology samples.
microsoft/ALAppExtensions – Repository for collaboration on Microsoft AL application add-on and localization extensions for Microsoft Dynamics 365 Business Central.
microsoft/AL – Home of the Dynamics 365 Business Central AL Language extension for Visual Studio Code.
StefanMaron/MSDyn365BC.Code.History – Contains the Microsoft Business Central Code. Updated each month.

Follow on Social Media

Twitter/X Hashtags: #MSDyn365BC | #BusinessCentral

Stay Connected

The Business Central AL development community stays active with valuable content on AL development, upgrades, integrations, and tooling improvements. Following #MSDyn365BC and #BusinessCentral on Twitter/X is a great way to catch new posts as they’re published.

Note: This review is compiled from publicly available blog posts and community resources. Links to external blog posts are provided for your information only and do not constitute endorsement or validation of their content. Publication information and availability are subject to change. Always verify information against official documentation for production use.

Permanent link to this article: https://www.dvlprlife.com/2026/05/weekly-review-business-central-al-development-may-17-23-2026/

May 21 2026

Round Three: AL EventLens

By Dvlpr in Tech & Tools
May 21, 2026

AL EventLens — browsing indexed event publishers in the searchable panel

Install from the Marketplace — Source on GitHub

Two extensions in, I didn’t plan a third so soon. But Business Central’s exploring event model was something I’ve wanted to do for a while, and it turned out to be a bigger task than the first two VS Code extensions.

A quick recap for anyone who hasn’t written AL: Microsoft Dynamics 365 Business Central is extended through events. Microsoft’s base application — and many of the ISV and PTE apps layered on top of it — publish [IntegrationEvent] and [BusinessEvent] declarations, and code hooks into them with [EventSubscriber]. It’s a clean model right up until you need to answer a basic question: who is listening to this event? Or the other direction: the event I just subscribed to — does it still exist, and where?

VS Code gives you nothing here. The publisher you care about might be in your workspace, or it might be buried in a compiled .app file in .alpackages whose source you can’t even open. The honest answer most days is a grep, then another grep, then giving up and reading the BaseApp source on GitHub.

I wanted that answered inside the editor. So I came up with AL EventLens.

Install from the Marketplace — Source on GitHub

What it does

AL EventLens indexes the [IntegrationEvent], [BusinessEvent], and [EventSubscriber] declarations in your workspace and in the .app packages sitting in .alpackages, resolves which subscriber connects to which publisher, and surfaces the event publisher and subscribers.

A searchable panel. A publisher list on the left, each row carrying a live subscriber count; a detail pane on the right listing the subscribers for the selected publisher with a resolved (✓) or unresolved (⚠) badge, file path, and line number. Click a subscriber to jump straight to its source. The App and Kind dropdowns filter the list, and the search box accepts app:, kind:, and object: prefixes for power-user narrowing.

An activity-bar view. A dedicated tree that drills four levels — source app → AL object kind → object → event — with (events / subscribers) counts on the intermediate rows so a busy subtree is obvious without expanding it. Dependency apps show their friendly name and vendor pulled from the package manifest.

Inline CodeLens. A live "N subscribers" lens sits above each [IntegrationEvent] and [BusinessEvent] declaration in the file you’re editing. Click it to open the panel scoped to that publisher.

The point of all this is the cross-app resolution. Each subscriber is matched against its target publisher and marked resolved or unresolved — and an unresolved subscriber almost always means the target app is simply missing from .alpackages, which is useful to know on its own. Resolved links are click-jumpable even when the publisher is contained within a compiled dependency.

Rounding it out: a Mermaid export command for dropping a subscriber graph into docs, incremental re-indexing on save so the index stays warm, a persistent cache keyed by (appId, version, mtime) so re-opening a workspace should load faster.

If you write AL and you’ve ever grepped four apps to find out who subscribes to one event, grab AL EventLens from the marketplace.

If you have any suggestions please let me know.

Permanent link to this article: https://www.dvlprlife.com/2026/05/round-three-al-eventlens/

May 19 2026

Weekly Review: Business Central AL Development – May 10–16, 2026

By Dvlpr in Weekly Review
May 19, 2026

Highlighting posts and resources from the Business Central development community — May 10–May 16, 2026

A quieter week in the community, but it’s all about BC 28.1. Stefano Demiliani previews GPT-5.3-chat as the default Copilot model plus an AL API for agent model selection, Steven Renders maps the full 28.1 feature set, and Yun Zhu drills into Layout Status governance for report layouts. On the tooling side, Gerardo Rentería ships AL Object Visualizer for VS Code and Teddy Herryanto reminds developers to turn on al.inlayhints.parameterNames.

Community Resources

Official Resources

GitHub Repositories

microsoft/BCApps – Repository for collaboration on Microsoft Dynamics 365 Business Central applications.
microsoft/BCTech – Business Central technology samples.
microsoft/ALAppExtensions – Repository for collaboration on Microsoft AL application add-on and localization extensions for Microsoft Dynamics 365 Business Central.
microsoft/AL – Home of the Dynamics 365 Business Central AL Language extension for Visual Studio Code.
StefanMaron/MSDyn365BC.Code.History – Contains the Microsoft Business Central Code. Updated each month.

Follow on Social Media

Twitter/X Hashtags: #MSDyn365BC | #BusinessCentral

Stay Connected

Permanent link to this article: https://www.dvlprlife.com/2026/05/weekly-review-business-central-al-development-may-10-16-2026/

May 14 2026

Using the Continue Statement in AL Loops

By Dvlpr in Tech & Tools
May 14, 2026

If you’ve spent any time writing AL, you’ve probably written the same pattern dozens of times: loop through records, check a condition, and either skip the row or wrap the rest of the body inside a big if block. It works, but the indentation creeps up fast, and the intent gets buried.

The continue statement gives us a cleaner way to do that. It’s a small addition to the language, but it’s one of those quality-of-life improvements that make loops noticeably easier to read.

Diagram showing a loop where some iterations are skipped with the continue keyword

What Is the `continue` Statement?

continue skips the rest of the current iteration of a loop and jumps straight to the next one. The loop itself keeps running—only the remaining statements in the current pass are bypassed.

It works inside the usual AL loop constructs:

repeat ... until
while ... do
for ... do
foreach ... in ... do

Think of it as the counterpart to break. Where break exits the loop entirely, continue just says “I’m done with this one—move on.”

Why You Should Care

Flattens deeply nested if blocks inside loops
Makes filter/skip logic read top-to-bottom instead of inside-out
Reduces indentation, which tends to reduce bugs
Matches the pattern that developers coming from C#, JavaScript, and most other languages already expect

How It Works

A few things worth knowing before you sprinkle continue everywhere:

continue only affects the innermost loop it appears in. If you’re inside a nested loop, it won’t skip the outer loop’s iteration.
In a repeat ... until block over a record, you still need Next() to advance the cursor. continue does not call Next() for you—but because Next() is part of the loop condition pattern (e.g., until Customer.Next() = 0), the loop still moves forward correctly when you use it the typical way.
continue outside of a loop is a compile error.
It’s available in recent runtime versions of AL (rolled out as part of the 2025 release waves), so make sure your project’s runtime target supports it before using it.

Before: The Nested `if` Pattern

Here’s the kind of code we’ve all written. We want to process customer payments, but skip those that are blocked or have no balance.

if Customer.FindSet() then
    repeat
        if not Customer.Blocked then begin
            Customer.CalcFields("Balance (LCY)");
            if Customer."Balance (LCY)" <> 0 then begin
                // ... do the actual work here ...
                ProcessCustomer(Customer);
            end;
        end;
    until Customer.Next() = 0;

It works, but the meaningful line—ProcessCustomer(Customer)—is buried two levels deep. Add another condition, and you’re fighting the indentation.

What About `break`?

A quick reminder, since the two often get mentioned in the same breath: break is not a replacement for continue. break exits the loop entirely—the moment it runs, the loop is done and execution moves on to whatever comes after the until (or end). It’s the right tool when you’ve found what you were looking for and there’s no reason to keep iterating, but it’s the wrong tool when you just want to skip the current row.

// `break` stops the whole loop after the first match.
if Customer.FindSet() then
    repeat
        if Customer."No." = 'C00010' then begin
            ProcessCustomer(Customer);
            break; // we're done — don't look at any more customers
        end;
    until Customer.Next() = 0;

Before continue existed, there was no clean equivalent. If you wanted to skip a single iteration, you really had two choices:

Wrap the loop body in nested if blocks (the “Before” example above).
Extract the body into a procedure and exit early from that procedure when a guard condition is hit.

The procedure trick worked, but felt heavy for what should be a one-line “skip this row” decision. continue finally gives us that one-liner.

After: The `continue` Version

Same logic, rewritten with continue:

if Customer.FindSet() then
    repeat
        if Customer.Blocked.AsInteger() <> 0 then
            continue;

        Customer.CalcFields("Balance (LCY)");
        if Customer."Balance (LCY)" = 0 then
            continue;

        // The actual work is now at the top level of the loop body.
        ProcessCustomer(Customer);
    until Customer.Next() = 0;

The “skip” rules are listed up front, each one reads as a single sentence, and the real work lives at the natural indentation level. This is the pattern I reach for most often.

`continue` in Other Loop Types

It works the same way in foreach and for:

foreach Item in ItemList do begin
    if Item.Blocked then
        continue;

    if Item."Unit Price" = 0 then
        continue;

    UpdateItemPrice(Item);
end;

for i := 1 to 100 do begin
    if i mod 2 = 0 then
        continue;

    // Only odd numbers reach this line.
    ProcessOddNumber(i);
end;

Gotchas and Recommended Approach

Nested loops: continue skips only the innermost loop. If you need to skip an outer loop’s iteration, you’ll need a flag variable or to refactor the inner loop into its own procedure.
Don’t forget Next(): In a repeat ... until Rec.Next() = 0 block, the until clause still runs after continue, so the cursor advances normally. Just don’t accidentally write a loop that depends on a manual Next() call inside the body before the continue—the continue will skip past it.
Use it for guard clauses, not control flow gymnastics: continue shines when you’re filtering or short-circuiting at the top of the loop. If you’re using it deep in the middle of complex branching, the loop body is probably trying to do too much—consider extracting it into a procedure instead.
Runtime version: Confirm your app.json runtime target supports continue before using it in a project that needs to deploy to older environments.

Wrapping Up

continue is a small language feature, but it pays off every time you write a loop that has to skip some rows. The “guard clause” style—list the skip conditions at the top, then write the real work at one level of indentation—reads better, reviews better, and tends to be easier to extend.

If you’ve been waiting for AL to catch up to the loop patterns you use in other languages, this is one of those nice ones to finally have.

Learn more:

Note: The code and information discussed in this article are for informational and demonstration purposes only. Always test in a sandbox first. The continue statement is available starting with the AL runtime version introduced in the Microsoft Dynamics 365 Business Central 2025 release wave 1.

Permanent link to this article: https://www.dvlprlife.com/2026/05/using-the-continue-statement-in-al-loops/

May 14 2026

May 2026 Cumulative Updates for Dynamics 365 Business Central

By Dvlpr in Cumulative Updates
May 14, 2026

The May updates for Microsoft Dynamics 365 Business Central are now available.

Before applying the updates, you should confirm that your implementation is ready for the upgrade and ensure compatibility with your modifications. Work with a Microsoft Partner to determine if you are ready and what is needed for you to apply the update.

Please note that Online customers will automatically be upgraded to version 28.0 over the coming days/weeks and should receive an email notification when upgraded.

Direct links to the cumulative updates are listed here:

Dynamics 365 Business Central On-Premises 2026 Release Wave 1 – 28.1 (May 2026)

Dynamics 365 Business Central On-Premises 2025 Release Wave 2 – 27.7 (May 2026)

Dynamics 365 Business Central On-Premises 2025 Release Wave 1 – 26.13 (May 2026)

Dynamics 365 Business Central On-Premises 2024 Release Wave 2 – 25.18 (April 2026)

If you’re looking for information on older updates, review the list here.

Permanent link to this article: https://www.dvlprlife.com/2026/05/may-2026-cumulative-updates-for-dynamics-365-business-central/

May 11 2026

Weekly Review: Business Central AL Development – May 3–9, 2026

By Dvlpr in Weekly Review
May 11, 2026

Highlighting posts and resources from the Business Central development community — May 3–May 9, 2026

A strong week for AL tooling and AI-assisted development. Vjeko ships AL MCP Bridge so any agent — Claude Code, Cursor, Codex — can drive the AL Language Server, and Javi Armesto introduces BCQuality, an open repo of remedial knowledge for AL coding agents. Gerardo Rentería pushes VS Code Agent Hooks onto Copilot, Steven Renders maps each AI assistant to the AL work where it actually pulls its weight, and Amol Salvi previews Clarity AI for decoding cryptic BC error messages.

Community Resources

Official Resources

GitHub Repositories

microsoft/BCApps – Repository for collaboration on Microsoft Dynamics 365 Business Central applications.
microsoft/BCTech – Business Central technology samples.
microsoft/ALAppExtensions – Repository for collaboration on Microsoft AL application add-on and localization extensions for Microsoft Dynamics 365 Business Central.
microsoft/AL – Home of the Dynamics 365 Business Central AL Language extension for Visual Studio Code.
StefanMaron/MSDyn365BC.Code.History – Contains the Microsoft Business Central Code. Updated each month.

Follow on Social Media

Twitter/X Hashtags: #MSDyn365BC | #BusinessCentral

Stay Connected

Permanent link to this article: https://www.dvlprlife.com/2026/05/weekly-review-business-central-al-development-may-3-9-2026/

May 10 2026

The right-click menu lands in Markdown Foundry 0.5.0

By Dvlpr in Tech & Tools
May 10, 2026

I shipped 0.5.0 of Markdown Foundry — my VS Code extension for markdown people — and the headline change is something I should have built first: a right-click menu.

By 0.4.0, the extension had grown to forty commands. Tables, headings, lists, links, images, a TOC, half a dozen formatting toggles. Every one of them was reachable from the Command Palette, which is fine if you remember the names. A user who installed the thing yesterday probably doesn’t remember the names. They open a markdown file, right-click, see VS Code’s standard menu, and have no idea any of those commands exist.

So 0.5.0 fixes the discoverability gap.

The right-click submenu showing the five sections

What’s in the menu

Right-click anywhere in a markdown file, and there’s now a Markdown Foundry submenu with everything in it, grouped into five sections:

Inline — Bold, Italic, Bold+Italic, Strikethrough, Inline Code
Block — Blockquote, Block Code, Bullet List, Numbered List, Task List
Heading — Heading 1–6, Promote, Demote
Insert — Horizontal Rule, Insert Link to File, Paste Link, Paste Image, Insert Table, TOC
Table — Align, Insert/Delete/Move Row & Column, Sort

VS Code renders horizontal dividers between groups, so it scans cleanly. The Table section disappears when the cursor isn’t inside a table — there’s no point showing “Move Column Right” while you’re typing a paragraph. That uses the same markdownFoundry.inTable context key already powering Tab navigation between cells, so it costs nothing extra.

A few commands didn’t make the cut. The cell-navigation triggers (Next Cell, Previous Cell, Next Row) live on Tab, Shift+Tab, and Enter inside tables — putting them in a right-click menu would be noise. Convert Selection to Table is a paste-flow command, not a cursor-position one, so it stays in the palette. Everything else is in the menu.

The other 0.5.0 changes

The submenu is the photogenic feature. Three smaller things shipped alongside it.

Insert Link to File opens a quick-pick of every file in the workspace (current folder first, then alphabetical) and inserts a relative-path link at the cursor. If the file is an image, you get ![alt](path); otherwise [text](path). When a selection is made, the selection becomes the link text. I built it to scratch a specific itch: writing a markdown post that links back to another file in the same repo, and being tired of typing the relative path by hand.

Toggle Task List Item used to operate on the cursor’s line only, even with a multi-line selection active. The two sibling commands — Toggle Bullet List and Toggle Numbered List — have already been applied to selections. Now, Toggle Task List does too. Plain lines become unchecked, unchecked become checked, checked become unchecked, all in one keystroke. Empty lines stay empty. With no selection, behavior is identical to before.

Paste Link got broader clipboard tolerance. It used to accept URLs from the clipboard. Now it also accepts absolute file paths and file:// URIs, which many file managers and screenshot tools drop on the clipboard. Image extensions become ![alt](path); everything else becomes [text](path). Paths that don’t exist on disk are rejected, so a typo can’t sneak through.

On building this in the open

Most of the code that landed in 0.5.0 was written by Claude Code, working through a queue of GitHub issues — a planner agent reviews the issue, a worker agent writes the PR, a reviewer agent checks it against the acceptance criteria and our CLAUDE.md conventions before I merge. The submenu was a good test of the loop: a package.json-only change with a sharp acceptance criterion (the Table section must appear and disappear correctly), and the reviewer agent caught the one thing I missed — a missing PR link in the CHANGELOG entry — without me having to read the diff line-by-line.

The agent loop isn’t the post, but the velocity it enables is part of why these changes are showing up so quickly.

Markdown Foundry 0.5.0 is live on the marketplace. Right-click into it.

Permanent link to this article: https://www.dvlprlife.com/2026/05/the-right-click-menu-lands-in-markdown-foundry-0-5-0/

May 09 2026

Selection Count 0.1.1

By Dvlpr in Tech & Tools
May 9, 2026

Selection Count v0.1.1

Selection Count 0.1.1 shipped today. No new features — three behavior corrections that surfaced during a post-v0.1.0 code-and-docs review and got fixed in a single afternoon. The extension is at marketplace.visualstudio.com/items?itemName=dvlprlife.selection-count. Full release notes in CHANGELOG.md.

For context: Selection Count is a tiny VS Code extension that puts live counts of the current selection — characters, words, letters, numbers, special characters — into the status bar. v0.1.0 shipped a week ago.

What’s fixed

Toggle / Configure now respect workspace scope (#22). Before this release, both Selection Count: Toggle Visibility and Selection Count: Configure Display wrote unconditionally to user (Global) settings. If you’d ever overridden any selectionCount.* setting at the workspace level, the workspace value kept winning after the Global write — the command appeared to silently no-op. The fix is config.inspect(key) to find the active scope, then write there.

Character count is now Unicode code points (#23). Previously text.length (UTF-16 code units), which counts an emoji like 🎉 as 2. With every other counter using \p{...}/u (code points), the totals didn’t reconcile — a selection of 🎉🎉🎉 reported chars: 6, special: 3 and the rest were 0. Switched to [...text].length. Now chars = letters + numbers + special + whitespace for any selection. Combining marks still count as separate characters; full grapheme-cluster counting (Intl.Segmenter) is a deferred follow-up.

Settings descriptions say “number,” not “digit” (#24). The number counter matches \p{N} — decimal digits and fractions like ½, superscripts like ², Roman numerals, etc. The README’s own example used ² while still calling the category “Unicode digits,” which read as a contradiction. Cheap fix; aligns the copy with what the code actually does.

If you’ve installed v0.1.0 already, VS Code will pick up 0.1.1 automatically. If not, grab it from the marketplace.

Permanent link to this article: https://www.dvlprlife.com/2026/05/selection-count-0-1-1/

May 08 2026

Quick Tips: Debug Copilot Agent Session Logs in VS Code

By Dvlpr in Quick Tip
May 8, 2026

Welcome to Quick Tips — a fast, focused series designed to help you work smarter.

Each post will give you one practical insight you can apply immediately, whether you’re coding, configuring your tools, or improving your workflow.

Here’s today’s Quick Tip:

Turn On Agent Debug Logs to See What Copilot Actually Did

VS Code 1.116 added the ability to view the Agent Debug Log for previous chat sessions, not just the one you’re in. With one setting enabled, every agent session is persisted to disk so you can go back and inspect tool calls, LLM requests, prompt file discovery, token usage, and errors after the fact.

If you’ve ever finished a long agent run and wondered “wait — which instructions actually loaded?” or “why did it skip that tool?”, this is the switch you want flipped.

How to Enable File Logging

Open Settings (Cmd + , on macOS, Ctrl + , on Windows/Linux)
Search for github.copilot.chat.agentDebugLog.fileLogging.enabled
Check the box to enable it

Or drop this directly into your settings.json:

{
  "github.copilot.chat.agentDebugLog.fileLogging.enabled": true
}

How to Open a Past Session

Click the ellipsis (...) menu in the Chat view and select Show Agent Debug Logs — or run Developer: Open Agent Debug Logs from the Command Palette
Pick a session from the list
Switch between Logs, Agent Flow Chart, and Summary views

Export and Import Sessions

The Agent Debug Logs panel toolbar has Export and Import icons in the top-right.

Export writes the current session to an OpenTelemetry JSON (OTLP) file — handy for sharing a repro with a teammate or archiving a tricky run for later analysis
Import loads a previously exported JSON file back into the panel, complete with its overview and metrics, just like a live session

Heads up: importing files larger than 50 MB triggers a warning. If you hit it, trim the file or export a shorter session.

Why It Helps

Debug custom agents, prompt files, and MCP tools without having to reproduce the issue live
See exactly which customizations loaded (and which were skipped) for any past run
Audit token usage and tool-call patterns to tune your workflow
Share repeatable bug reports by exporting a session log instead of pasting screenshots

Note: the Agent Debug Log panel is currently in preview, and logs are stored locally on disk — keep that in mind if your sessions include sensitive context.

Learn more in the Debug chat interactions docs.

Got a favorite shortcut or workflow tweak? Share it in the comments and subscribe to dvlprlife.com for more Quick Tips like this one!

Permanent link to this article: https://www.dvlprlife.com/2026/05/quick-tips-debug-copilot-agent-session-logs-in-vs-code/

May 04 2026

Round Two: Another VS Code Extension

By Dvlpr in Tech & Tools
May 4, 2026

Selection Count — live counts in the VS Code status bar, in text and icon formats

After Markdown Foundry shipped, I had no plans to immediately go again. Then I noticed the same blind spot every time I selected text in VS Code: the bottom-right corner shows the cursor position and the length of the selection, but nothing about what’s actually in it. How many words is this paragraph? How many digits in this CSV column? How many non-letter, non-digit characters in this filename? VS Code shows (351 selected) and stops there.

I wanted more. Specifically, five categories — characters, words, letters, numbers, and special characters — visible in the status bar, toggleable per-category, in either plain text or codicons.

So I vibe-coded a second extension: Selection Count.

Install from the Marketplace — Source on GitHub

What it does

The status bar shows live counts for whatever you have selected. By default it shows characters and words; via the Selection Count: Configure Display command you can toggle on letters, digit-counts, and special characters. Multi-cursor selections aggregate across every range. Empty selection hides the indicator entirely — the whole feature is selection count.

The format setting flips between plain text — 351 chars, 57 words, 281 letters, 0 nums, 11 special — and codicons, where the labels are replaced with VS Code’s built-in glyphs (symbol-string, whole-word, case-sensitive, symbol-number, symbol-operator). Either way, hovering the indicator shows a long-form breakdown.

The counters are Unicode-aware: é counts as a letter, ² counts as a number. That last detail tripped me up — see below.

How round two went

Same agentic workflow as Markdown Foundry: an agents/ directory, a CLAUDE.md rulebook, and the issue → planner → worker → reviewer cycle. The big difference this time was muscle memory. I knew where the friction was, what to write down up front, and which conventions to put in CLAUDE.md so the agents wouldn’t re-litigate them every PR. Three things stood out.

Drafting the issue body really matters. For each piece of work, I wrote a complete acceptance-criteria checklist before letting the agent loop touch it. That up-front investment removed almost all of the “wait, what did you mean by X” questions during implementation. The plan-driven cadence is the unlock — without a tight plan, agents wander.

The reviewer caught a real bug. The counter spec called for \p{L} and \p{N} (Unicode letter / number categories), but the README still described them as ASCII-only — A–Z and 0–9. The drift was flagged during a README review pass and we shipped a fix before publish. That’s exactly the failure mode a written rulebook plus a reviewer pass is supposed to catch.

Scope narrowing is fine. The original plan for the README demo section called for four GIFs. By the time we got there, three screenshots and one GIF told the story well enough, so we shipped that and tracked the rest as follow-ups. Not every ideal plan survives the reality of polishing a weekend extension. Cutting scope to ship beats polishing in private.

What’s next

A few obvious follow-ups are tracked but deferred:

Default keybindings for the Toggle Visibility and Configure Display commands.
Debouncing the status bar update for very large selections (a 100k-line select-drag currently runs five regexes per move tick).
A multi-cursor demo GIF, since the static screenshots don’t show aggregation.

None of these are urgent. The extension does its job at v0.1.0; sharper UX can land in 0.1.x as feedback comes in.

If you live in selections and want a tighter readout than VS Code’s built-in (N selected), grab it from the marketplace. And if you’ve been on the fence about agentic development workflows: writing the rules down once and letting the agents follow them really is the unlock.

Permanent link to this article: https://www.dvlprlife.com/2026/05/round-two-another-vs-code-extension/

Recent Posts (May 17–23, 2026)

➡️ 1. Be Careful With Visual Studio Code Extensions…

➡️ 2. Manage Business Central Docker Containers With BC Container MCP

➡️ 3. I Tag a Work Item. Sometimes I Come Back to a PR.

➡️ 4. Above the AI (Agentic) Harness

➡️ 5. Global Memory for Your VS Code Agent: Preferences That Follow You

➡️ 6. Quick Tip: Almost Every BC Major Release Gets Paused. Are Your Environments Ready?

Community Resources

Official Resources

GitHub Repositories

Follow on Social Media

Stay Connected

What it does

Recent Posts (May 10–16, 2026)

➡️ 1. Dynamics 365 Business Central Agents: Announcing New Updates

➡️ 2. Quick Tip: What’s in Business Central Update 28.1

➡️ 3. Business Central 2026 Release Wave 1 (BC28.1): Control the Lifecycle of Report Layouts (Layout Status)

➡️ 4. Visualize Your AL Objects in a Tree View, Filter and Navigate Directly in VS Code

➡️ 5. BC Friday Tips #72 Inlay Hints

Community Resources

Official Resources

GitHub Repositories

Follow on Social Media

Stay Connected

What Is the continue Statement?

Why You Should Care

How It Works

Before: The Nested if Pattern

What About break?

After: The continue Version

continue in Other Loop Types

Gotchas and Recommended Approach

Wrapping Up

If you’re looking for information on older updates, review the list here.

Recent Posts (May 3–9, 2026)

➡️ 1. The MCP Bridge: AL Language Tools for Every Agent

➡️ 2. BCQuality: An Agentic Vision for AL Development

➡️ 3. VS Code Agent Hooks: Give Copilot Context Before the First Message

➡️ 4. How Do I: Choose the Right AI Assistant for AL Development?

➡️ 5. Meet Clarity AI: The AI Assistant That Explains Your Business Central Errors

Community Resources

Official Resources

GitHub Repositories

Follow on Social Media

Stay Connected

What’s in the menu

The other 0.5.0 changes

On building this in the open

What’s fixed

Turn On Agent Debug Logs to See What Copilot Actually Did

How to Enable File Logging

How to Open a Past Session

Export and Import Sessions

Why It Helps

What it does

How round two went

What’s next

Recent Posts

Categories

Tag Cloud

Oh hi there 👋

Archive

What Is the `continue` Statement?

Before: The Nested `if` Pattern

What About `break`?

After: The `continue` Version

`continue` in Other Loop Types