20260326 - From AI Novice to Agentic Thinking For the CAL Brained

Overview

Jeremy Visca explains why AI and agentic development is hard for developers who are used to writing and understanding every line of code. He describes the shift from deterministic code to fuzzy outcomes, where the LLM acts as the compiler and the context and prompts are the product. He shows a customer example where GitHub Copilot was used to create a Power BI API endpoint in minutes.

The session then covers practical habits: strong tests and performance tests, domain-expertise checks on agent output, the master loop of asking, correcting and asking what was learned, and keeping context concise. It closes with ways to start gently (documentation, test expansion, scaffolding, design critique), use on legacy code, and career progression for developers.

Key points

• Value shifts from writing lines to specifying intent clearly and validating outcomes. The speaker calls this trading certainty for velocity, which is hard in an industry that needs correct accounting outcomes.
• Testing is the safety net for AI-generated code. Agents can be taught to publish to Docker or a sandbox and run the tests. However, they may not think to write performance tests, and they sometimes change tests to match the code.
• Senior developers should apply BC domain knowledge to agent output. For example, when a field is added to a sales order, check the credit memo, invoice and shipment, reverse processes and register writes.
• Context windows are often about 128,000 to 160,000 tokens. Each rule in the BC Code Intel knowledge repo is kept under 100 lines because the agent might not read past that. Separately, when the window fills up, summarization (compaction) can drop critical constraints. Start new sessions often.
• The master loop: ask the agent to do the work, correct what it got wrong, then ask what it could have done differently next time.
• Good starting points are documentation (READMEs, commit explainers, XML documentation with summary tags), extra test scenarios, table and codeunit scaffolding, and design critique from several stakeholder views.
• Agents can be used on legacy code maintained since NAV 4.0. The gains come from parallel work and quality uplift (documentation, tests) rather than raw speed.

Features

AL objects mentioned

As heard in the captions. A name that matches one object page by exact type and name links to it; the others stay as named.

• other “BC Code Intel MCP” at 25:41
• other “BC Code Intel” at 40:41
• other “MCP servers” at 41:00
• other “telemetry buddy” at 41:12
• other “object ID Ninja” at 41:12

Quotes

• 7:42 “We bring change to our customers, and now change has come for us.”
• 8:08 “you come at things with the I write every line of code. I understand everything that’s in here.”
• 9:53 “In agentic world, the agent might do different stuff every time. That’s a very, very big shift.”
• 10:05 “your intent and your ability to sculpt the intent for the agent to understand is now the new mastery.”
• 11:58 “matters more than whether or not you’re working with ai”

Disclaimers in the video

• 13:02 subject-to-change: For now, it’s optional
• 20:43 coming-later: there’s an upcoming session in June that will be very much around this
• 32:35 subject-to-change: the agent didn’t understand BC well enough to do those things correctly
• 37:05 subject-to-change: there are other places and models where you can get up to a million, but context window isn’t everything
• 51:43 coming-later: You should be able to get to a point by maybe end of summer where you can try out at …
• 57:37 coming-later: one of my projects for this quarter two in the months ahead April through June is looking at what can …
• 58:08 coming-later: There may be some updates to AL guidelines coming in the upcoming years upcoming weeks rather to help with providing some additional skills

Presenters (as heard): Luke van Vught, Jeremy Visca, Stefan Møller, Henrik, Luke, Kamel, Vico, Brandon Sanderson, Dean Jackson, Mir Kasim, Peter Konijn.