The bet stands. Halftime.
In May 2026, at Days of Knowledge Central, I made a bet: “In 12 months, no consultant in this room will write another requirements document. No developer will hand-code another line of code.” Deliberately provocative, due May 2027. On 28 October at Directions EMEA in Paris, we were halfway. Time for an honest check, and that was the frame of my session “The 2027 BC Professional: Thriving in an AI-First Ecosystem”.
The halftime score from my own team is sobering and encouraging at once. In our BC development (17 developers, internal survey, October 2026, self-reported), the share of AL code still typed by hand sits at a median of 50 percent. The range runs from 5 to 90 percent. Same tools, same team, a factor of 18 between them. The tools are not the bottleneck. Habits are.
The question everything revolved around: if an agent can do your job by Monday, what is the customer paying you for on Tuesday? If you don’t have the answer, your customer will give it to you eventually.
Developers: from writing to conducting
Writing code got cheap. Checking it got cheap too. What didn’t get cheap: conducting the whole thing. The developer of 2027 no longer types AL by hand, no longer reviews line by line, no longer writes tests or documentation themselves, no longer deploys manually. They compose the agent team, write the score (architecture, guidelines, acceptance criteria), conduct the whole lifecycle and own the outcome in production.
This is not a vision. In our internal KUMA DevAgent, five of seven roles run today: analyse the spec, plan the work, write the AL, review every change, optimise performance. Test and deployment are next. The human stands at the start (intent, scope, acceptance criteria) and at the end (release decision based on spec, findings and tests). In between, no human writes code, and nobody has to read it. The human reads the review report, not the lines.
Important: this is not less review. It is far more. Agents check every change, more often than any human team could. With BC 2026 release wave 2 (29.0), Microsoft ships the groundwork: AL language intelligence, debugging and profiling for AI agents.
Four skills for developers in 2027, and none of them is typing: know what an agent is (a role description plus the tools it may use, written as a text file); build specialist agents instead of one super-agent that copies you; evaluate and prove (test sets and acceptance criteria, so you know when an agent is right); and orchestrate the loop across the whole lifecycle.
Consultants: the software explainer is dead
Nobody books a consultant to explain the requisition worksheet. Customers expect us to understand, live and advise their processes. Not their screens. Over: the click-through feature demo, the fit-gap list of functions, training users on input forms. In demand: designing how their purchasing works from A to Z, walking through the customer’s day, a process map with the pain points marked.
The tool for that is four questions, department by department: Where is time lost? What fills the day? What repeats every day? Where do things break (data entered twice, moved between systems)? The answers are your agent backlog.
Four skills for consultants in 2027: know the toolbox (what an agent is, what a skill is, what BC ships out of the box); process first, before anyone talks features; prototype with the customer, in the workshop, with their scenario, same day; and carry the change, from fear to approval. None of these skills is explaining features.
Not everything belongs in an extension
The best answer may not live in Business Central at all. The BC AI landscape in October 2026 has three shelves: Copilot features included in the licence (chat, summarise, analyse lists, autofill, bank reconciliation, e-documents), first-party agents billed in Copilot Credits (Sales Order Agent and Payables Agent GA, Expense Agent in preview), and build your own (Agent SDK for AL in preview, Copilot Studio, BC MCP server GA, Microsoft Foundry).
Add to that the direction Microsoft is setting: Copilot becomes the front end, systems run headless, BC stays the system of record. The Role Center becomes optional. Satya Nadella in October 2026: “organize software around the work, rather than us working around the software.”
In practice: the old reflex to a customer asking for a new screen was a PTE with new pages. The new way: prototype first (a vibe-coded Power App in an hour, on BC data, not for production), the customer clicks through it the same day, then decide where it lives (Power App, Copilot, agent or extension), then build it properly. Prototype first. Decide the platform second. Write code last.
Tuesday: what they will still pay you for
Everyone gets the same agents. Technology stops being the difference. What remains, personal view rather than forecast: knowing the customer’s business (their processes, their people, their pain, not the software), designing the work (which steps go to agents, which stay human, and why), owning the outcome (an agent can’t be accountable) and taking people with you. When everyone has the same technology, the relationship is the difference.
Which brings us to the elephant in the room: our own business. If effort drops, do we sell hours or outcomes? My take: price the customer’s gain, per processed order, per invoice, per hour saved. If we don’t, a competitor will. What do we do with the time we win? Depth over volume, deeper into each process, plus the projects we declined for lack of people. And how do juniors learn judgment if AI writes the first draft? Apprenticeship: they review agent output with a senior, from day one.
The human side starts with us
To the seniors in the room: used wrong, AI makes your 20 years worth nothing. Used right, it makes them worth more than ever. And the half-life of knowledge keeps shrinking: on-premises, skills lasted years; in the cloud with two major releases a year, months; with AI and new models every few weeks, weeks. SaaS made learning a habit. AI makes it the job.
For decades, users and partners alike worked inside the system. That habit is ending, and it is a transformation for all of us. Taking people with you means: hear the fear (“My biggest fear was that it gets so powerful it replaces us.”) and answer it rather than wave it away; show value in their process, in their order, their invoice, their Monday morning, not in a demo; keep humans in control (the agent proposes, a person approves); and build AI literacy, for users, not just admins. The EU AI Act asks that of every deployer in Article 4 anyway. The same is true for us partners: we have to change first. Be careful, not afraid.
Start Monday
Developers: pick one recurring step of your day, define a checkable result, let an agent do it and compare with your way. Then the next step. Consultants: ask the four questions in one department of one customer and bring back a process map. Everyone: use what’s already there (Researcher, Copilot in Excel and Word, Cowork, Agent Builder). Leaders: go first, block two hours a week per person for real agent work, and measure the share of hand-typed work every quarter.
The bet stands. Due May 2027.
Four sentences to take home: Used wrong, AI makes 20 years worthless; used right, it multiplies them. Stop writing AL by hand, own the result. The software explainer is done, design the process. Take people with you: the tech is the easy part, people are the job.
Believe the unreal. What sounds impossible today is next year’s routine.
Slides and links
[Placeholder: embed or link the slides as PDF, Directions2026_Session1_2027-BC-Professional]
Further reading: Microsoft Learn on Copilot and agents in Business Central, Agent SDK for AL (preview), AL agent tools, the microsoft/BCQuality repository with quality rules for agents, and the AB-900 and AI-901 certifications. The second session from Paris, “Vibe Coding: Just because you can, doesn’t mean you should”, follows in the next post.
Discover more from Lubenheimer
Subscribe to get the latest posts sent to your email.