4. Nov. 2026 · @Marco Lubig
How much of your AL do you still type yourself?
That is the question I opened my second session at Directions EMEA 2026 in Paris with, together with the answer from my own team: 17 BC developers, last month, self-reported. Median 50 percent typed by hand, range 5 to 90 percent. One answer I particularly liked: “30 percent if autocomplete counts as AI. 65 percent if it doesn’t.”
The session was called “Vibe Coding: Just because you can, doesn’t mean you should”. Level 100, for consultants, developers and project managers, with one promise: no code on the slides. It was not about whether to use AI. It was about how you build with AI: prompt in, code out, or an agent team. Four questions in 45 minutes: What is vibe coding, really? Why does it break in Business Central? What does an agent team do differently? And when should you vibe code anyway?
What vibe coding really is
The term comes from Andrej Karpathy, February 2025: “There’s a new kind of coding I call vibe coding, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.” In plain words: you prompt, you try the result, you prompt for changes. By definition, nobody reads the code.
There are three ways to build with AI, and they differ in what you look at and who checks. AI-assisted is autocomplete: Tab accepts a suggestion, the unit of work is a line or a function, you check every line. Good for daily work. Vibe coding is “Make me a page that…”, accept all, the unit of work is the whole feature, you look at the result and glance at the code now and then, if there’s time. Good for things you throw away. Agentic engineering is the target picture: the spec is approved, agents run, the unit of work goes from ticket to production, you look at the spec, review reports and tests, at code only on findings. Agents check every change, you approve. Good for things you ship.
The difference isn’t the model. It’s the system around it.
Why it breaks in Business Central
One small feature: a minimum margin on sales lines. Vibe coded in a day, it works in the sandbox, a few AL files, done in seconds. Then the twelve months after, as a ticket history. Go-live: the clerk gets a permission error instead of the margin message (permissions). Week 3: the French subsidiary sees “Confirm Margin” in English (translations). Month 2: prices including VAT, the check says 20 percent margin, the real one is 1 percent (the code itself). Month 4: a copied order posts at 3 percent margin, nobody approved it (tests). Month 6: version 2 stores the confirmed margin, no upgrade code, old approvals look invalid (upgrade path). Month 12: a colleague should change it. No tests, no docs. Nobody dares (docs).
Five of these six tickets are real, from our own experiment, more on that below. In Business Central, the AL you can vibe code is the smallest part of what you deliver. The code is one line in the app folder. The product is the folder.
A thought experiment that worked well in the room: you board a plane. A: its software was vibe coded. B: every change was checked, and the check is documented. Hands up, which one do you board?
What an agent team does differently
Build a team, not a prompt. The target picture: a spec agent turns the ticket into a spec, the human approves it. Then plan (with test cases), code, review (including performance), test, docs, deploy to sandbox, the human approves the release, deploy to production. Findings go back to the coding agent until they are clean. Every agent reads the same shared knowledge: guidelines, BC rules, glossary and the Definition of Done. No human writes code in this loop, and nobody has to read it. Five of these seven roles run in our internal KUMA DevAgent today.
An agent is nothing magical. It is one file. Our performance reviewer has 42 lines: a role (use for, not for), two tools, both read-only, thirteen anti-patterns as a checklist (Get inside a loop, CalcFields inside a loop, Commit inside a loop) and a defined output format. Written once, run every time. Our planning agent has 410 lines. That is a job description, not a prompt.
The experiment: same prompt, same model, twice
We ran it. The same three-sentence prompt (minimum margin check on sales orders and invoices, setup field, block the line, special permission with reason code, posting must fail), once with Copilot alone, once with our KUMA DevAgent. Same model.
Copilot alone: zero questions, no plan, zero test cases, no review, code in seconds. The DevAgent: four questions before the first line (prefix, margin formula, where the setup lives, permission model), a plan with eleven assumptions written down as open, 40 test cases with test users and expected results, review 1 with a No-Go and one blocker, rework, review 2 with a Go, five documents. Both wrote nearly the same code. Only one of them can prove it.
What the review caught, and what vanilla would have shipped: without a new permission set, the clerk hits a permission error instead of the margin message (ticket 1 of the story, found before go-live). The ticket said “block the line”; vanilla shows a message and lets the clerk continue, the block only comes at posting, three screens later. Copy Document carries confirmation and reason code into a new order, which posts without an approver. And vanilla calculates the margin on the gross amount; on a document with prices including VAT, it is simply wrong.
One team is a tool. Many teams with one Definition of Done are a factory: repeatable (the same ticket gets the same checks, whoever typed it), scalable (a new project is one context file, eight minutes) and measurable (every review is a document with blockers, warnings, loops and open tests). The factory doesn’t replace developers. It replaces hoping.
Your new job
Control moves from reading code to owning the system. Own the spec: write it, let AI challenge it, approve it. Consultants: your workshop notes are the input. Define checks: the Definition of Done, written once for every agent. Approve: the spec before work starts, the release before production. Fix the agent: a bug is a missing check. Improve the team, not the code.
The PTE Definition of Done has ten items: The code does what the spec says. The extension model fits next to the customer’s apps. Permissions work without SUPER. Data classification on every new field. Translations in the customer’s languages. The upgrade path survives the next version. Tests prove it works tomorrow. Telemetry shows when it breaks. Performance holds a million rows, not just ten in the demo. And lifecycle and deployment survive two major releases a year, monthly updates and several environments.
If your job was writing AL, it just ended. If your job was knowing what AL needs, it just got bigger.
When you should vibe code anyway
Vibe coding is exactly right when the code isn’t the product. Four conditions, and all four must be true: Throwaway (it gets deleted, nobody maintains it). Small audience (you, and the customer in the room). Approved data (a sandbox is not automatically safe: approved data, restricted permissions, controlled connections). Learning first (the goal is alignment and feasibility, not delivery).
For consultants it shines in four places. In the workshop: “Can we see this field on the order?” Mock it in a sandbox while the customer watches. As a process prototype: a clickable app on the Power Platform to walk through a process before anyone writes a spec. As a feasibility check: does the API answer like we think? A quick probe before you promise an integration. And for your own tools: data checks, migration prep, a quick report only you use. Not just BC, whatever shows the idea fastest. The prototype feeds the spec, not the release.
What Microsoft said the same week
Two announcements from Monday’s keynote, as I heard them, and what they mean for this talk. First, Microsoft is building agents for AL development in VS Code. The groundwork is already shipping in BC 2026 release wave 2: AL agent tools, a bridge so agents can talk to BC, agent-driven debugging and profiling, object IDs allocated by agents. So the team gets Microsoft-built players. The job description stays yours: the spec, the gates, the Definition of Done.
Second, vibe coding inside the client: users will build their own customizations through Copilot, inside Business Central. No VS Code, no partner in the loop. Which means question 4 now applies to every user: prototype, small audience, approved data. For anything that stays, the ten checks still apply. Microsoft brings the platform. The Definition of Done is still yours.
My take, as a timeline: in 2026, the front-runners stopped writing AL; they write specs and checks. In 2027, most AL is written by agents, and writing it by hand becomes the exception. In 2028, nobody asks who wrote the code, only who owns the Definition of Done. If you sell typing time, you sell the part that is getting cheaper fastest.
Three things to take with you, and one step for this week
Vibe coding is a prototype tool. Use it, then throw the result away. For anything you ship, build a team, from spec to production, and nobody has to read the code. In BC, the Definition of Done is the job: write it down once, give it to every agent.
Consultants: prototype one workshop idea and turn what you learned into a spec. Developers: run one ticket twice, Copilot alone, then with a review agent, and compare what you had to read. Project managers: make the ten checks your Definition of Done for every PTE.
Just because you can: you can vibe code a prototype. You shouldn’t vibe code a release.
Slides and links
Sources: Andrej Karpathy on vibe coding (February 2025) and on agentic engineering (February 2026), Martin Fowler, Vibe Coding (bliki, May 2026), VS Code custom agents and subagents (documentation), microsoft/BCQuality on GitHub, Microsoft Learn on AL agent tools and BC 2026 release wave 2. The first session from Paris, “The 2027 BC Professional”, is in the previous post.
Discover more from Lubenheimer
Subscribe to get the latest posts sent to your email.