An LLM Is Not an Oracle. Use It That Way and You'll Fail.

An LLM answers the same question differently every time, and everything you built on determinism will betray you. The problem becomes acute when your customer's safety, wellbeing, or earnings depend on what your application returns. How will your software keep its promise if it is nondeterministic and its output quality varies?
The answer is in traditional, algorithmic software. The hard truth is that AI systems cannot cope with the demands of production without thoroughly designed algorithmic support around them.
This talk shows how that is built in .NET. The model supplies judgment, your C# computes the outcome, and tests assert invariants instead of text.

AI Is Not New. AI Is Not an LLM.

Let's bust those myths right away. AI has been in use for seventy years, and it was solving real problems long before it could write prose. Its mathematical foundations span three centuries. Yet for most developers working today, AI arrived in 2022, in the form of an LLM. LLMs are just one corner of the field, though a very loud one.
This talk is not a history lesson. It is an account of how programming was shaped by decades of attempts to make machines decide and, more importantly, how they failed. What survived quietly turned into ordinary software nobody calls AI anymore. The talk ends where we are now, with LLMs and the systems built around them. It is the oldest story in engineering: success arriving through a long series of failures.

Functional Thinking with C# 15: The Missing Parts

Functional programming had crossed paths with C# years ago, adding a lot to the language's specification. We have functional sequences with LINQ, built on top of list comprehension. There are lambdas and closures, support for tuples, records, and pattern matching. We can build our own functional extensions. Yet, some crucial parts are still missing. Common functional types, such as Option and Either, are not available, and there is no supporting syntax. We are finally getting the union types, but will the programmers know how to use them effectively?
In this presentation, you will gain a wider picture of using functional concepts in modern C#, without having to step back to the traditional, imperative coding style. The goal of the game: Stay within C#, keep thinking functionally, and don't worry too much about missing types or syntax.

This talk was presented at conferences a few years back. The current state of this talk is mostly the evolution of introductory demos available on my YouTube channel: https://www.youtube.com/playlist?list=PLSDYwLgFqaX78eEg_YKs0wHmOMi7_ggZr

Produce Embarrassingly Simple Design with Advanced C# 15

Mixing functional programming and metaprogramming into good-old object-oriented C# is not new. Still, so many programmers don't see it clearly yet: Those paradigms are not additions to an established programming model; they are genuine parts of a unified programming method, support for which is progressively being added to the C# programming language.
In this session, we will demonstrate the use of the latest functional additions to C#, which will be integrated with object-oriented and even procedural elements into a unified design that effectively solves a practical problem.

This session was presented several times (under different titles): IT Konekt 2021, Sinergija 2021 in Belgrade, NDC Porto 2022, Techorama Antwerp 2022, and Sinergija 2022.
I have written the entire demo and script from scratch several times to always include the latest syntax relevant to the topic.

Beyond AI Hype: Where do Code Generation Tools End?

Generative AI hype might be receding a bit these days, and we can finally assess how the landscape is changing for hands-on programmers.
While some developers still worship AI and its power to develop entire features on a whim, others notice design flaws, persistence errors, mismatched legal reports, and outright delusional implementations! What shall we do about it?
In this talk, we will try to look beyond generating a portion of code. Can we keep maintaining generated code in the upcoming years? Can AI generate unit tests that won't turn out to be a white lie about our product's quality? Can a tool trained on myriads of lines of mediocre code still write quality code?
And we didn't even touch on the process of specifying precise requirements...
Those are the hard questions we will try to answer in this talk.

This talk is a 100% coding session using C# in VS Code with Claude Code and Codex.
This talk is the result of several years of experiments I ran and documented in a series of YouTube videos: https://youtube.com/playlist?list=PLSDYwLgFqaX4Ke4h0bVzgadqOesECqKj2
This session was presented at Developer Week 24 conference, Nuremberg (no link available).

Where Is C# 15 Heading (and Why, Exactly?)

We have witnessed a gradual but substantial shift over the years in how the C# language is meant to be used. Between the lines, C# is becoming progressively functional, and for a reason!
In this session, we will demonstrate the use of the latest functional additions to C#, which are necessary to address the challenges in modern software development. We will outline the reasons why such a paradigm shift is a necessity in the cloud-first, reactive, parallel, event-driven, and whatnot world we are casting in software these days.
To adapt, some programmers will have to learn C# over again!

This session was presented (on C# 14 at the time) at Sinergija 2023 Belgrade (November 2023), .NET Conf 2023 Bulgaria (December 2023), Peak IT 006 Brasov (May 2024). No links available.

AI Tools Make Incremental Coding More Important Than Ever

One of the sure signs of an experienced programmer is the ability to develop a feature in small increments, whereas a less experienced programmer would struggle to keep all the desires in their head all at once, which often leads to incoherent, needlessly complex implementation. But the times, they are changing again. How will the advent of generative AI affect our core habits?
In this talk, we shall analyze the benefits of using generative AI tools in small increments. You will witness how that approach can empower every programmer with the knowledge of the finest techniques in programming.

This is the AI-powered version of the talk I have been giving in different forms over the course of 10 years. The talk has always been accepted well by the audience, often quoted as "eye-opening".

Where is Generative AI Taking Us: A Senior Programmer's View

Artificial intelligence is rapidly evolving from a background tool into an "algorithmic colleague". It is already fundamentally transforming the nature of work, both for senior and junior programmers, though not in the same way. This session provides a critical overview of how AI approaches software development, establishing the indispensable role of a human-in-the-loop. We will inevitably dive into the new division of labor, discussing the evolving roles, and identifying the emerging jobs of the AI era alongside those that are now retiring or just fading out.

This is a no-code session, but with deep technical insight into the working principles of LLMs, deep neural networks, and generative AI tools. The talk ends in an attempt to understand how generative AI tools are changing and will change software development, from the developer's perspective.

Presented at PeakIT Brasov in April 2026.

Microsoft Agent Framework Is the Easy Part: Incorporating It Right Is Hard

Semantic Kernel and AutoGen were folded into Microsoft Agent Framework, though the interface underneath them did not change. The major question is not which framework we adopt, but which decisions we make when designing applications equipped with AI. Calling a language model from C# today takes an afternoon. Living with that call takes longer, and that is where the real costs lie.
In this talk, we will examine the boundary between your code and the LLM, and discuss where Microsoft Agent Framework and Microsoft.Extensions.AI each belong in your applications.