A Practical Mental Model for Using GitHub Copilot in AL Development

GitHub Copilot is powerful.
That much is clear.

What is less clear — especially in AL development — is how to use it without losing control. Many frustrations with Copilot are not caused by incorrect output, but by unclear expectations.

This short series of posts explored Copilot from a different angle.
Not what it can do, but when to use each mode — and why.

This post brings those ideas together into one practical mental model.

Why This Series Exists

Most Copilot discussions focus on features, prompts, or demos. That approach often leads to confusion when Copilot behaves differently than expected.

In AL projects, structure matters:

where logic lives
how responsibilities are separated
how extensions evolve over time

Copilot does not remove those concerns. It amplifies them.

The goal of this series was not to turn Copilot into “magic”, but to make its behavior predictable.

One Mental Model, Five Modes

Across the series, one pattern kept returning: intent matters more than tooling.

Each Copilot mode supports a different kind of intent:

Chat helps you think about a solution
Ask helps you understand existing code
Edit helps you improve selected code
Agent helps you implement incrementally
Plan helps you clarify intent before acting

These modes are not interchangeable. They are complementary.

Most frustration comes from using the right tool at the wrong moment.

How the Modes Work Together

Copilot works best when the modes are combined intentionally.

A typical flow in AL development might look like this:

Plan to agree on structure and responsibilities
Agent to implement one step at a time
Edit to refine code where needed
Ask to review or explain decisions

Not every task needs all modes.
Not every mode needs to be used every day.

The important part is that execution follows intent, not the other way around.

What Changed for Me

Working with Copilot this way changed how I approach development.

I now:

spend more time clarifying intent up front
guide Agent incrementally instead of asking for finished solutions
use Edit and Ask more deliberately, and Chat more sparingly

As a result:

Copilot feels more predictable
less time is spent undoing generated code
architectural decisions stay explicit

Copilot did not become smarter.
My expectations became clearer.

Where This Leaves Us

GitHub Copilot is not a replacement for experience.

It does not understand your architecture unless you explain it.
It does not make design decisions for you — it only makes them visible when they are implicit.

Used thoughtfully, Copilot can be a strong accelerator in AL development.
Used casually, it often creates more work than it saves.

The difference is not the tool.
It is how intentionally you use it.