Explaining GitHub Copilot Agent Mode to Junior AL Developers

Note: This blog is a personal notebook. I write it to record what I work on, for my own reference, not to publish it on social media or to promote myself. If a post is still useful to you, I am glad, but that is not why it exists.

This post was published on January 11, 2026. Software versions, product features, links, and tool availability may have changed since then. Always check official documentation for the latest information. Some screenshots show small details. Zoom in on the page to see them clearly.

When junior developers first see Agent Mode in VS Code, the options can look larger than the work. Instructions, prompt files, skills, custom agents, tools, permissions, and MCP look like separate features.

Reduce it to one idea: each feature solves a different type of reuse. This post explains the layers from a Business Central view, with short AL examples for team discussions.

Problem

The usual mistake is one large prompt for everything: team standards, task instructions, and too much context. The result is usually good enough to be misleading.

In Business Central, unclear AI usage costs more than untidy code: weak test coverage, wrong assumptions in posting or validation logic, and extra review work. Junior developers need to know which mechanism fits which problem.

Why this matters

AL work has many repeatable patterns: test writing, extension review, upgrade impact analysis, and codeunit documentation. With the right layer for each, Copilot becomes more predictable and easier to trust.

Four layers of reuse

Layer What it is Best use in BC work
Instructions Reusable rules that apply often Team conventions, naming, testing expectations, guardrails
Prompt files Reusable task requests you run manually Generate tests, review code, write docs, analyse changes
Skills Reusable mini-workflows with instructions, resources, and examples Upgrade review, test review, refactoring checklists, release prep
Custom agents Named AI roles with specific tools and boundaries Planner, implementer, reviewer, architect

It is easy to remember: rules, task, workflow, role.

A school works the same way: class rules on the wall, a worksheet for one task, a lab manual for an experiment, and a subject teacher with their own tools.

Two more concepts come early. A read-only planning flow and a code-editing flow should not share one agent setup. And when you connect MCP or an external service, ask what Copilot can access and do, not only what it can know.

Demo steps

One short AL example for each layer:

1. Instructions

Team standards that apply to many tasks.

# .github/copilot-instructions.md

- For business rules, generate AL tests before implementation.
- Use descriptive procedure names.
- Prefer small codeunits with one clear responsibility.
- Avoid hidden database side effects.
- When changing posting logic, mention test impact and permission considerations.

How to explain it: this is the default behavior that the team wants from Copilot, not a task.

2. Prompt files

A task that repeats.

---
description: Generate AL tests for a business rule
---

Create an AL test codeunit for the selected codeunit.

Requirements:
- Cover happy path
- Cover boundary values
- Cover one invalid input case
- Use clear test names
- Return only the test code

How to explain it: a stored task request. You run it when you need it.

3. Skills

A task that needs more than a prompt. An al-upgrade-review skill can hold a SKILL.md file, review steps, examples of obsolete handling, and a compatibility checklist.

---
name: al-upgrade-review
description: Review AL changes for upgrade risk.
---

# AL Upgrade Review

Check:
- field renames and deletes
- obsolete state and reason
- upgrade codeunit need
- API or page impact
- test impact

How to explain it: a reusable procedure for one AL workflow.

4. Custom agents

A task that needs a different role or tool boundary.

---
name: BC Planner
description: Create implementation plans for AL features
tools: ['search/codebase', 'search/usages']
---

You are a Business Central planning agent.
Do not edit code.
Return:
- scope
- AL objects affected
- risks
- tests needed

How to explain it: you select which senior colleague to ask: the planner, the implementer, the reviewer, or the architect.

Scope

This model is simplified on purpose. It skips the VS Code settings, the Agent Mode variants, MCP setup, and enterprise governance. The goal is a model that a junior developer can use immediately.

Risks and limits

These features do not improve AI output automatically. Weak instructions give weak results, a skill with bad examples multiplies the wrong pattern, and a custom agent with broad permissions adds noise.

Do not start with the most advanced mechanism. A junior developer must first see the difference between instructions and prompt files.

Next iteration

  • Start with one instruction file for the team’s AL rules.
  • Add prompt files for repeated tasks, such as test generation and code review.
  • Introduce one or two skills, such as upgrade review.
  • Create custom agents only when roles and tool boundaries must differ.
  • Review permissions and connected tools before you increase autonomy.

Closing note

Different problems need different mechanisms: instructions for rules, prompt files for tasks, skills for workflows, and custom agents for roles. Fit them to your delivery flow, and Agent Mode becomes easier to explain, govern, and trust.

← Back to AI