Navigating the Labyrinth of Explainable AI: Ethical Implications and Practical Steps

More and more decisions are made or quietly nudged by AI, which is fine right up until someone asks why, and the honest answer is “the machine felt strongly about it.”

In a world increasingly run by these systems, being able to explain them has stopped being optional. We demystify Explainable AI (XAI): what it is, why it matters, and how to build models that are not merely clever but accountable and willing to show their working. We weave theory together with real-world scenarios, including the instructive carnage of AI going wrong for want of explainability, and give serious attention to the ethics.

Because the more powerful these systems get, the less comfortable “it felt strongly about it” becomes as a legal defence. With, as ever, some fun along the way.

Break the speed limits: optimize your C# Code!

Computers are gloriously fast these days, a fact that holds right up until you're juggling thousands of simultaneous requests and the hardware starts giving you a look. Then you optimise, ideally without turning your codebase into write-only hieroglyphics.

Join Dennis for the top tips to make C# blazingly fast:
- the inner workings of the BCL,
- what the CLR quietly does on your behalf,
- how to work with the garbage collector rather than against it,
- and rather more.

Think of this as the breadth-first scenic tour: the overview before the deeper systems-programming talks start lifting the floorboards.

If speed is your thing, buckle up.

Born to run: build the ultimate playlist with AI agents and Microsoft Agent Framework

Generative AI is clever, and, left to its own devices, a bit like a GPS that confidently directs you into a lake. The magic happens when you give an LLM the ability to actually do things: call your systems, fetch real data, take action, all without going full HAL 9000. Enter the Microsoft Agent Framework: the production-ready successor to Semantic Kernel and AutoGen, plus MCP for plugging tools in.

We prove it by building, live and in C#, an agent that assembles the perfect playlist for your mood, whether you're pounding the pavement like Springsteen or reclining on the sofa contemplating whether 42 really is the answer.

Expect real-time coding, a thrilling bug or two, and considerably fewer Spanish Inquisitions than a Monty Python sketch.

Can of course also be done in Dutch,

Agents that actually ship: production AI agents in C#

Everyone has built a demo agent. It answered correctly, someone in the room said “transformative,” and a manager began quietly drafting a press release.
Then it met production. Real users, real cost ceilings, and real consequences when it confidently does the wrong thing at three in the morning while you sleep. This talk lives in that gap. Using the Microsoft Agent Framework and C#, we build a multi-step agent and then do all the unglamorous things the demos skip: tool calls over MCP, guardrails, evaluations so you actually know whether it works, cost and latency control, and a plan for the moment it goes gloriously off the rails. Live coding, real failure modes, and the patterns that stop an agent becoming an expensive, confident accident.
You'll leave with a checklist for getting from “neat” to “in production and not on fire.”

Live coding; reliable internet or local-model fallback advised.

Give your AI a toolbelt: Model Context Protocol from zero to production

An LLM that can only talk is a very expensive parrot. The Model Context Protocol (MCP) is how you give it hands: letting models discover and call your tools, data and services through one civilised interface instead of the usual tangle of bespoke glue and quiet despair.
A hands-on tour for .NET developers: what MCP actually is, how clients and servers really talk, how to build your own server to expose your systems safely, and the security questions you must answer before handing a probability engine the keys to anything that matters.
We build one live and break it on purpose, because that is both more fun and considerably more educational. You'll leave able to make your existing systems available to AI. Deliberately, securely, and without rewriting the world.

The Evaluation Gap: how do you actually know your AI feature works?

A room full of senior engineers and CTOs, every one of whom had shipped an AI feature to production, and not one could tell you whether it actually worked. They knew it ran. Running and working, as anyone who has owned an old car understands intimately, are different things. That's the gap: not a knowledge gap, a measurement gap: a whole industry steering by a dashboard where the needles are painted on.
“You can't unit test a model” is a comforting lie, true in roughly the way “you can't measure the ocean with a ruler” is true. You're not testing the model; you're testing the behaviour of your feature, which has acceptance criteria even if you've never written them down (doesn't leak the system prompt, returns valid JSON, declines to advise the customer to set themselves on fire).
We swap assertEquals for evaluation suites, baselines and the occasional LLM-as-judge. You'll leave able to answer “does it work?” with something more dignified than a hopeful shrug.

STDIO ate my device code: three bugs everyone hits wiring an LLM to real infrastructure

A weekend project: a small MCP server, one tool, running locally, talking to Microsoft Graph, authenticating with device code. Simple. Except no mail arrived. No error, no exception, no log line, just a silence with real menace in it.
This is the full autopsy.
The three bugs that killed it are the three everyone hits when wiring an LLM client to real infrastructure: a .NET console app speaking MCP over stdio, launched as a child process, with genuine auth and a genuine external API, and not one of them, infuriatingly, is an “AI bug.”
We debug it live, learn how MCP-over-stdio actually behaves, why “it runs” and “it works” are entirely different sentences, and how to make these failures loud instead of sulking in silence. You'll leave able to diagnose the next one in minutes rather than over a lost weekend.

Live debugging; recorded fallback prepared for the inevitably cursed conference wifi.

AI is an amplifier. And your codebase is the thing being amplified

A confession to open with: ask me to draw a circle by hand and you'll get something resembling a potato having an identity crisis. Give me Photoshop and I'll draw perfect ones all day, which makes me handy with a tool, not an artist. AI in coding works exactly the same way. For a strong developer it's rocket fuel; for everyone else it cheerfully generates problems you won't notice. The string concatenation in a hot loop that's hundreds of times slower, sitting quietly in server-side code called by thousands of clients. It works. That's the dangerous part. This talk is about staying the artist rather than just the person holding the brush: where AI accelerates good engineering, where it lovingly amplifies your worst habits, and why senior judgement matters more in the AI era, not less.

The polyglot AI engineer: Python for .NET developers who refuse to pick a side

For years the best AI examples were all in Python, and the .NET world quietly pretended not to mind. That gap is closing. .NET now has genuinely first-class AI tooling, but the research, the notebooks and half the internet's best ideas still turn up in Python first, smug and largely uncommented. The modern AI engineer is bilingual, and that's a superpower rather than a betrayal of your C# vows. A C# developer to his bones, Dennis gets you fluent enough in Python to read the papers, run the notebooks and smuggle the good ideas back into your .NET stack: the syntax, the quirks, and the small cruelties that ambush C# muscle memory. You won't leave a convert. You'll leave dangerous in two languages, which is precisely what AI work demands.

Local heroes: running generative models on your own hardware

Cloud AI is wonderfully convenient, right up until you read the bill, or the privacy policy, or watch your legal team read the privacy policy and go quiet.
Sometimes the smart move is to bring the models home: running image and language models on hardware you control, where your data never leaves the building and never auditions for someone else's training set. A practical, hype-free tour of self-hosted generative AI. Which open-weight models are actually worth running, what hardware you genuinely need (versus what the internet insists you need), how to set it up, and when self-hosting is wisdom rather than an elaborate way to make your own life harder.
We generate live and privately, and talk honestly about the trade-offs in cost, speed and quality. You'll leave able to stand up your own private AI lab and argue the cloud-versus-local case with actual numbers.

Low-code grew a brain: building AI-powered apps with Copilot Studio and agents

Low-code never went away: it went off and grew an AI brain. What used to be drag-and-drop forms is now a place where you wire up agents, natural-language interfaces and Copilot-powered logic in an afternoon. For seasoned C# developers that's either an existential threat or the best productivity hack you've been studiously ignoring. Join Dennis for a live build that turns a vague business request into a working, AI-augmented app; the sort of thing that used to mean three sprints and a tearful stand-up, and an honest reckoning with where low-code-plus-AI genuinely shines, where it falls flat on its face, and how it fits alongside (not instead of) your “real” code. Come for the speed, stay for the trade-offs, leave with your craftsmanship intact.

Closer to the metal: unsafe code, pointers, and P/Invoke in modern C#

Most C# developers spend entire careers comfortably above the waterline, blissfully unaware of how far down the language actually goes. But beneath the managed surface lurk pointers, raw memory, stack allocation and a direct line to the operating system, and occasionally that's precisely where you need to be, wrapping a native library or coaxing performance out of something that has never heard of the CLR and frankly resents being asked. So we go diving. We write genuinely unsafe code on purpose: pointers, fixed buffers, ref structs, stackalloc, and use P/Invoke to call straight into native APIs without leaking, crashing, or summoning anything from the realm of undefined behaviour. When this is a brilliant idea and when it is a loaded foot-gun (both are true, sometimes simultaneously). Expect at least one thrilling segfault, handled with the calm of a man who has done this before and lived to tell it.

The memory games: Span, the heap, and making peace with the garbage collector

The garbage collector is that conscientious colleague who tidies up after everyone, right up until it decides to tidy up mid-request, at which point your p99 latency leaps and the entire team turns to look at you. Knowing what the GC is actually up to, and how to give it less to do, is the difference between software that scales and software that merely stutters apologetically. A deep, practical tour: how the generational GC really works, server versus workstation modes and the newer adaptive behaviour, and, the part you can act on first thing Monday: Span, Memory, stackalloc, ArrayPool and object pooling, with honest allocation measurement instead of optimistic guesswork.
You'll leave able to read an allocation profile, cut the garbage, and inform the GC, politely but firmly, that you've got this one.

Async all the way down: what await actually does (and how to stop deadlocking)

Every C# developer uses async/await. Rather fewer can tell you what the compiler actually builds when you type it, why ConfigureAwait exists, or how a single innocent .Result can deadlock an entire web request and quietly ruin an otherwise lovely afternoon. This is for the developer who'd like to graduate from using async to understanding it. We take await apart: the state machine the compiler writes on your behalf, where the thread pool fits, what a SynchronizationContext is and why it has personally ruined so many afternoons, and when ValueTask earns its keep over Task. Then the bits the tutorials skip: cancellation that genuinely cancels, Channels-based pipelines, and patterns that stay correct under real concurrency rather than merely on your laptop. With classic deadlocks reproduced live, because nothing teaches concurrency quite like watching it fail in public.

Autonomy theatre: why “capable” and “trustworthy” are not the same word

There's a corporate trust-fall exercise: cross your arms, close your eyes, and topple backwards, betting that someone is standing behind you. This is, increasingly, how companies deploy AI agents. Except they've skipped the part where they check whether anyone is actually there. We've moved from AI that answers to AI that acts, and somewhere between demo and deployment a quiet substitution happens: “the agent CAN do this” becomes “the agent SHOULD do this, unsupervised.” Capable and trustworthy are not synonyms; they're not even close. With real failures and the maths nobody wants to do: an agent that's right 95% of the time, acting a thousand times a day, is fifty confident, articulate, fully automated mistakes daily, each signed with your company's name. We separate genuine autonomy from autonomy theatre, and treat human-in-the-loop as a control rather than a courtesy.

This is more a keynote, but can be done as normal breakout session.

Your AI strategy is a shopping list wearing a PowerPoint badge

It's Tuesday, 4pm, and your manager has that look: “we need an AI strategy, figure it out.” A week later the strategy arrives: buy everyone Copilot licences, hand out training accounts, and crown whoever burns the most tokens “AI Expert of the Week.” That is not a strategy. That is a shopping list in a costume, and bolting on a vector database merely makes it a more expensive shopping list. Strategy is the art of making integrated choices under uncertainty to build an unfair advantage, and it answers three questions: where are we playing, how will we win, and what are we deliberately NOT doing? That last one is the tell. If your AI strategy can't help you say no, it's a wish list with a budget. We start from the business outcome and only then ask where AI accelerates it, because AI is a magnifier of your strengths and your messes in equal measure.

A keynote, but can be done as a regular breakout session as well.

SaaS isn't dying. Your interface is: building for the age of agents

SaaS vendors sit on the genuinely good stuff: data, business logic, rules, workflows, permissions, years of hard-won domain decisions, historically monetised through the screens. But customers increasingly want it to work “slightly differently for my use case,” so vendors keep bolting on settings and tabs inside tabs inside tiny bureaucratic wardrobes, until the product is powerful and painful in roughly equal measure (you may remember this happening to a word processor). The uncomfortable shift: the application layer is becoming less defensible. When customers can vibe-code their own interface on top of your platform via MCP and agent-ready APIs, the screens stop being the product: the domain model, the logic and the trust layer become it. For anyone who builds or buys platforms: what “agent-ready” really means, the new commercial models it opens, and the genuine risk of being made redundant by your own customers.

A keynote, but can be done as a breakout session.

Leading humans in the age of agents

Every leader is currently being told that AI changes everything, usually by someone with something to sell. Having spent the last while actually leading AI work, Dennis arrives with a more useful and considerably more reassuring message: it changes a great deal, but not the things you'd expect, and emphatically not the part where your job is mostly about people. This keynote separates the genuine shifts: how teams are shaped, what “productivity” even means once a junior dev commands an army of agents, where the new risks like to hide, from the ambient panic. We talk about leading teams whose tools are cleverer than last year's, keeping humans in the loop where it actually matters, and resisting the urge to automate the soul clean out of your organisation. You'll leave clearer about which parts of the job to defend and which to hand over with a glad heart.

Who's accountable when the AI is wrong?

Here's a question that's wonderfully easy to dodge. That is, right up until a regulator, a journalist, or a visibly unhappy customer asks it for you: when your AI gets it wrong, who exactly is responsible? With the EU AI Act now baring its teeth and “the algorithm did it” no longer accepted in polite company, every leader using AI needs an answer ready before they need it badly. This keynote translates governance, explainability and risk out of compliance-deck dialect and into decisions a leader can actually make: what “explainable” has to mean in practice, where accountability really sits, how to govern AI without strangling it in its cradle, and the uncomfortable questions worth asking before you ship rather than during the post-mortem. No legal background required; you'll leave able to ask the right questions and sleep a little better.

This is a keynote, but can be done as a regular breakout-session

From coder to Director of AI without losing your soul (or your shell prompt)

Somewhere along the way, the person who only wanted to write good code ends up with a title, a team, and a calendar that's 60% meetings about meetings. This is the story of making that leap into AI leadership: the things that helped, the things that nearly broke me, and why I still keep a terminal open like a comfort blanket. A candid, funny talk about staying technical enough to be useful while leading at scale, leading in a field that reinvents itself roughly every six months, and the imposter syndrome that never entirely leaves (you just acquire better company). For the senior developers eyeing the leadership ladder and quietly wondering whether they'll have to surrender the part they love. Spoiler, gently delivered: you don't.

The Blind Leading the Blind: managing people when you have no idea what you're doing

Managing people is hard enough; it becomes properly daunting when you suspect you haven't the faintest idea what you're doing. If you feel like a deer caught in headlights, take comfort: you have a great deal of company, much of it also in management. In this talk I share practical, hard-won tips for faking it convincingly until you genuinely make it: the do's and don'ts (such as actually listening to your team, and setting expectations clearly enough that nobody suspects you're speaking in tongues), how to wrestle imposter syndrome down to a manageable size, and how to adopt a growth mindset so that next time you can fake it even better. Whether you're a brand-new manager or simply sharpening your leadership, you'll leave with the confidence, and the humour, to lead with style, even if your style is rather more “accidental leader” than “natural-born boss.”

Workshop: Architecting AI With .NET

Building an AI agent that works in a demo is the easy 20%: the part that earns applause and the word “transformative.” The other 80%, the boring load-bearing engineering that decides whether the thing survives a Tuesday in production, is what this full day is about. Framework names keep changing (Semantic Kernel, Microsoft Agent Framework, Foundry, whatever ships next quarter), but the production problems are stubbornly eternal.
Across the day we build a genuinely agentic C# system the way a grown-up .NET application is built, and face every question teams hit the moment the prototype stops being cute: where the agent lives, what's allowed to call what, how tools get their dependencies, how to keep business rules out of your prompts and in code you can actually test, how to log prompts without building a surveillance swamp or a future legal exhibit, what happens when the model times out or loops or is talked into something foolish by a malicious support ticket, and the one every demo dodges: how do you test a thing that answers differently every time?
We assemble it all into a deliberately boring, sturdy reference skeleton you take home, because boring, in production, is the highest compliment there is. For C# developers who know .NET well and AI patterns barely, and who would very much prefer their agent didn't become an expensive, confident accident

Full day (half-day and conference-length versions available) · hands-on C# · .NET 10 · has sold out on first outing

Attendees need laptops with a .NET 10 SDK; room with power and reliable internet. Half-day version covers architecture, tools and testing; conference-length distillation also available.