Cloud & Code Oost Meetup november 2026

13 november 2026 • Technologie • 23 min leestijd

Op de allereerste editie van Cloud & Code Oost zaten we met zoveel mensen dat de zaal bij Covadis over de maximumcapaciteit heen ging.
Een goed teken voor een regio waar veel bedrijven met de Microsoft-stack werken, maar waar je voor een meetup meestal een uur of meer moet rijden.
Deze blog is geschreven voor IT-professionals.

Waarom deze meetup?

De organisatoren Sander ten Brinke (Microsoft MVP en organisator van de Dev Sessions Zwolle meetup) en Hans Muns (freelancer en Microsoft Certified Trainer) spreken zelf regelmatig op evenementen. Ze merkten dat bijna alle .NET-meetups een flink eind rijden zijn en besloten er zelf een in het oosten te starten.

Het concept:

3 à 4 keer per jaar, roulerend door de regio, zodat niet steeds dezelfde mensen ver hoeven te reizen.
Een gastheer regelt zaal, catering en audio. Deze keer was dat Covadis.
De organisatie regelt sprekers, communicatie en socials.
Geen pitches. Geen reclame voor bedrijf X of Y en de gedragscode is simpel: doe normaal.

Deze editie liep nog via Luma. Vanaf de volgende editie gaat het over naar Meetup.com, dus reviews achterlaten helpt de groep groeien. Ook zoeken ze sprekers uit de regio, ook als je nog nooit op een podium hebt gestaan. Je kunt je onderwerp aanmelden via Sessionize of gewoon een van de organisatoren aanspreken. En heb je een werkgever die een volgende editie wil hosten, laat het weten.

Het programma

17:30 Diner
18:30 Welkom
18:40 Wat is er nieuw in C# 15? (Fons Sonnemans)
19:40 Dokter, mijn agent doet raar (Ruben Scheedler, Sopra Steria)
20:25 Netwerken, hapje en drankje

De eerste talk: wat is er nieuw in C# 15?

De eerste spreker was Fons Sonnemans: trainer, 14 keer Microsoft MVP en ontwikkelaar van een flinke verzameling puzzelspelletjes met miljoenen downloads. Fons programmeert al sinds Clipper en Smalltalk en werkt tegenwoordig vooral met C#, ASP.NET Core en XAML. Zijn puzzelspellen waren live te zien: hij liet Rummi zien, inclusief de moeilijkheidsniveaus Easy tot Expert en een multiplayer-modus. De agenda van de talk: collection expression arguments, union types, closed hierarchies, extension indexers, labeled break/continue en een aantal kleinere onderwerpen.

Hij begon met een eerlijke constatering: C# 15 viel hem tegen. Waar eerdere versies tientallen features brachten, zijn het er nu vijf van enige omvang, plus wat kleinere dingen.

Wat heb je nodig? Visual Studio 2026 en target framework .NET 11. Zit je nog op .NET 10, dan kun je de language version handmatig op 15.0 zetten. Dat is officieel unsupported, maar wel handig om te experimenteren.

1. Collection expression arguments

Sinds C# 12 kun je collecties met vierkante haken initialiseren. Daar zat één gat in: constructorargumenten zoals een capacity of een comparer. Dat kan nu met with(...) als eerste element:


HashSet<string> names =
[
    with(StringComparer.OrdinalIgnoreCase),
    "Ellen", "ellen", "Jim"
];
// names.Count == 2: de comparer ruimt de duplicaten op

Tip: vergeet de komma na with(...) niet. In de demo gaf [ with() "Fons", "Hans" ] direct een CS1003: Syntax error, ',' expected.

Een paar kanttekeningen uit de talk:

Het werkt voor types met een publieke Add-methode: HashSet, List en dergelijke. Dictionary komt pas in C# 16. Queue en Stack werken niet, want die hebben Enqueue en Push in plaats van Add. Met een extension method kom je er wel.

Let op de gegenereerde code. Fons decompileerde het resultaat met ILSpy. Met een capaciteit op een List ziet de bron er zo uit:


List<string> names = [with(capacity: 6), "Fons", "Jim", "Ellen"];

en dit maakt de compiler ervan: een lijst met die capaciteit, waaraan de elementen één voor één worden toegevoegd.


List<string> list = new List<string>(6);
list.Add("Fons");
list.Add("Jim");
list.Add("Ellen");
List<string> names = list;
Console.WriteLine(names.Capacity); // 6
Console.WriteLine(names.Count);    // 3

Laat je de capaciteit weg, dan maakt de compiler een lijst met exact de juiste grootte, vult die via een span en slaat de bound checks over:


int num = 3;
List<string> list = new List<string>(num);
CollectionsMarshal.SetCount(list, num);
Span<string> span = CollectionsMarshal.AsSpan(list);
span[0] = "Fons";
span[1] = "Jim";
span[2] = "Ellen";
List<string> names = list;
Console.WriteLine(names.Capacity); // 3
Console.WriteLine(names.Count);    // 3

Zijn advies: laat de capaciteit bij een List weg, of roep zelf EnsureCapacity aan. Misschien past Microsoft dit nog aan in een tussentijdse compilerupdate.

De IDE helpt met een refactoring (Ctrl+.) die oude initialisatiecode omzet naar de nieuwe syntax.

Fons’ oordeel: nieuwe wijn in oude zakken. Je kon dit al, nu kan het op een andere manier. In de zaal liepen de meningen over de syntax uiteen, van “vreselijk” tot “mooi”.

2. Union types

De grote naam van de avond, na zo’n 24 jaar wachten. Union types vormen volgens Fons het zesde type in het typesysteem, naast class, struct, interface, enum en delegate. (Een record is in feite een class of struct.) Je declareert een type dat precies één van een aantal opties kan zijn. Schematisch:


public record Cat(string Name, int Lives);
public record Dog(string Breed);
public record Bird(string Breed);

public union Pet(Cat, Dog, Bird);

string Describe(Pet pet) => pet switch
{
    Cat c  => $"{c.Name} {c.Lives}",
    Dog d  => d.Breed.ToUpper(),
    Bird b => b.Breed,
};

Een case-type kun je direct toewijzen, want er is een impliciete conversie. Via de constructor kan ook:


Pet pet1 = new Cat("Whiskas", 8);
Pet pet2 = new Dog("Tekkel");
Pet pet3 = new Pet(new Cat("Whiskas", 8)); // kan ook

Wat opviel:

Een Pet accepteert alleen Cat, Dog of Bird, dus geen strings of andere types.
Exhaustive switch expressions. Je hebt geen default nodig. Mis je een case, dan krijg je een warning. Die waarschuwing komt alleen bij switch expressions, niet bij switch statements en een bijbehorende code fix ontbrak nog in de gebruikte build.

Je kunt code toevoegen. Denk aan methodes en operators. Fons liet een Length-union zien van meters en feet, met een +-operator:


public record struct Meters(double Value);
public record struct Feet(double Value);

public union Length(Meters, Feet)
{
    // Property
    public double TotalMeters => this switch
    {
        Meters m => m.Value,
        Feet f   => f.Value * 0.3048,
    };

    // Method
    public Length Add(Length other) => new Meters(TotalMeters + other.TotalMeters);

    // Operator
    public static Length operator +(Length left, Length right) => left.Add(right);
}

Length tenM = new Meters(10);
Length twoF = new Feet(2);
Console.WriteLine(tenM.Add(twoF).TotalMeters); // 10.6096
Console.WriteLine((tenM + twoF).TotalMeters);  // 10.6096

Je kunt je eigen union schrijven, met een [Union]-attribuut en de IUnion-interface. De compiler genereert zelf altijd een struct die value types boxt en de inhoud als object? opslaat. Wil je iets anders, dan schrijf je hem zelf. Dat kan ook als class, of generiek (de bekende Result<T>-achtige gevallen):
```
using System.Runtime.CompilerServices;

[Union]
public class Result<T> : IUnion
{
    public Result(T? value) { Value = value; }
    public Result(Exception? value) { Value = value; }
    public object? Value { get; }
}
```

Het addertje is dat het gegenereerde type een struct is met een object als backing field. Zit er een value type in (zoals een record struct), dan krijg je boxing. Wie performance-gevoelig werkt, kan zelf een union schrijven met aparte velden per type, bijvoorbeeld een int en een bool met een discriminator-byte ernaast. Met het non-boxing access pattern (een HasValue-property en een TryGetValue per case-type) kan pattern matching die waarden zonder boxing uitlezen. Het voorbeeld hieronder is gebaseerd op Fons’ slide, waarvan het einde ontbrak; dat deel is aangevuld volgens dat pattern.


[Union]
public readonly struct IntOrBool : IUnion
{
    private readonly int _intValue;
    private readonly bool _boolValue;
    private readonly byte _tag; // 0 = none, 1 = int, 2 = bool

    public IntOrBool(int? value)
    {
        if (value.HasValue) { _intValue = value.Value; _tag = 1; }
    }

    public IntOrBool(bool? value)
    {
        if (value.HasValue) { _boolValue = value.Value; _tag = 2; }
    }

    public object? Value => _tag switch
    {
        1 => _intValue,
        2 => _boolValue,
        _ => null,
    };

    // Non-boxing access pattern
    public bool HasValue => _tag != 0;
    public bool TryGetValue(out int value)  { value = _intValue;  return _tag == 1; }
    public bool TryGetValue(out bool value) { value = _boolValue; return _tag == 2; }
}

Fons’ praktische tip: maak je union readonly:


public readonly union Pet(Cat, Dog, Bird);

Dat voorkomt defensive copies bij read-only fields, in-parameters en dergelijke. In de decompiled code zag je die kopieën verdwijnen. Zijn eindoordeel: “Eigenlijk zijn het gewoon structs, maar nu met een keyword erbij.”

3. Closed hierarchies

Een closed class kan alleen binnen dezelfde assembly worden overgeërfd:


public closed record class GateState;
public record Closed : GateState;
public record Open(int Percentage) : GateState;

Op zijn slide kreeg het één zin: een publieke basisklasse waar niemand buiten je assembly van kan erven. Omdat de compiler alle afgeleide types kent, kan een switch over GateState exhaustive zijn zonder default. Voeg je later Destroyed toe, dan geeft de compiler direct een melding op elke switch die dat nog niet afhandelt. Het lijkt qua doel op unions, maar het zijn twee losstaande features.

4. Extension indexers

Extension members (uit C# 14) kunnen er nu ook indexers bij hebben. Het demovoorbeeld was een indexer op IEnumerable<int> die onder water ElementAt aanroept:


IEnumerable<int> numbers = Enumerable.Range(1, 10);
int third = numbers[2];   // 3
int last  = numbers[^1];  // 10

public static class SequenceIndexer
{
    extension(IEnumerable<int> sequence)
    {
        public int this[int index]   => sequence.ElementAt(index);
        public int this[Index index] => sequence.ElementAt(index);
    }
}

Fons raadde dit af, want bij grote collecties is dat een performancevalkuil: elke aanroep doorloopt de reeks opnieuw. Een beter voorbeeld zat er niet in.

5. Labeled break en continue

Dit was Fons’ persoonlijke favoriet. Wil je uit een geneste loop ontsnappen, dan was goto tot nu toe de enige optie (break stopt alleen de binnenste loop):


for (int i = 10; i < 40; i += 10)
{
    Console.WriteLine(i);
    for (int j = 1; j < 5; j++)
    {
        Console.WriteLine($"{i}\t{j}");
        if (i + j == 23) goto exitLoop;
    }
}
exitLoop:
Console.WriteLine("Done");

Nu geef je de buitenste loop een label en break je daarnaartoe (of continue je):


outer:
for (int i = 10; i < 40; i += 10)
{
    Console.WriteLine(i);
    for (int j = 1; j < 5; j++)
    {
        Console.WriteLine($"{i}\t{j}");
        if (i + j == 23) break outer;
    }
}
Console.WriteLine("Done");
// Uitvoer: 10, 10 1, 10 2, 10 3, 10 4, 20, 20 1, 20 2, 20 3, Done

In ILSpy zie je dat de compiler er onder water gewoon gotos van maakt (lowering). Maar je eigen code blijft er leesbaarder van.

Het restje

Nog genoemd, maar niet uitgediept: non-virtual static interface members op oudere runtimes, een uitbreiding rond struct layout (extended layout), memory safety voor unsafe code (nog in preview voor de volgende versie), een uitbreiding voor file-based apps, waarmee je nu een extra bestand kunt includen dat meegecompileerd wordt, en de breaking changes.

Mijn conclusie

Als je C# 15 afmeet aan het aantal features, is het een bescheiden release. De waarde zit in de grotere bouwstenen: union types en closed hierarchies maken domeinmodellen en foutafhandeling strakker en de compiler dwingt af dat je alle gevallen afhandelt. Houd bij unions wel rekening met boxing en maak ze readonly. En bij collection expression arguments loont het om af en toe naar de gegenereerde code te kijken.

Na een korte pauze volgde een tweede talk en daarna was er tijd om te netwerken met een hapje en een drankje.

GenAIskunde voor gen AI: zo genees je een zieke AI-agent

De tweede talk op de eerste Cloud & Code Oost meetup begon met een spreker in doktersjas. Ruben nam ons mee naar zijn kliniek voor “genaiskunde”: de geneeskunde voor gen AI. Zijn uitgangspunt is dat agents die niet doen wat je wilt niet kapot zijn, maar ziek. En zieke dingen gooi je niet weg, die probeer je te genezen.

Het publiek deed live mee. Iedereen scande een QR-code en stemde via de telefoon op de diagnose en de medicijnen per patiënt. Alleen de duimpjes-reacties moesten uit, want een eerder publiek bleek er een rood-tegen-blauw-gevecht van te maken.

De anatomie van de homo agenticus

Eerst een kort hoorcollege. Een agent bestaat uit een LLM met daaromheen een stuk software: het harnas (de agentic layer). Dat harnas heeft twee taken:

De agent dingen laten doen in plaats van alleen tekst genereren. Dat gebeurt met tools: gewone, traditionele programmaatjes zoals een bestand aanmaken of een commando uitvoeren.
De agent langdurig aan een doel laten werken via de agent loop: observeren, redeneren, handelen, reflecteren en weer van voren af aan tot het doel gehaald is.

Het belangrijkste onderdeel is het context window, het korte-termijngeheugen van de agent. Bij elke stap stuurt het harnas het hele context window naar de LLM met de vraag wat er nu moet gebeuren. Dat window is daarmee de enige knop waaraan je kunt draaien. Dat is de geboorte van context engineering.

Ruben ontleedde het context window laag voor laag:

Algemene instructies: system prompts en guardrails.
De agent file: de persona, oftewel hoe de agent zich moet gedragen.
De metadata van skills en tools, zodat de agent weet wat hij kan.
Het gesprek zelf.
De resultaten van tool calls en de redeneringsblokken.

Ruben bouwde het context window stap voor stap op met een robotdokter als voorbeeld. Zo groeit de “very long string” die elke keer naar de LLM gaat:


System prompt:  You are nice.
Guardrails:     Do not hurt anyone.
Agent file:     You are a doctor and you cure patients.
Skill metadata: diagnosing, prescribing medication, performing surgery
Tool metadata:  stethoscope
Conversation:   ["I'm sick!", "Let's diagnose you then."]
Tool result:    "no heartbeat"

De LLM concludeert dan: “You do not have a heartbeat. Thinking about it, that could be an issue.” Het plaatje maakt meteen duidelijk dat alles wat in dat venster staat het gedrag bepaalt.

Daarna gingen we langs drie patiënten. Elke patiënt had een voicemail met symptomen en het publiek stelde een diagnose en koos medicijnen uit de medicijnkast.

Patiënt 1: Jesse Junkyard (hallucinaties en aannames)

Jesse hallucineert en doet aannames. De diagnose is hypoinformatia: een tekort aan informatie. Het publiek zat er goed op: 21 van de 35 stemmen gingen naar hypoinformatia. De medicijnkast stond vol afleiders, zoals “NON-NEGOTIABLE Therapy”, “Ozempic” en een “NEPAL Plane Ticket – Spiritual Retreat”.

Ruben illustreerde het met een voorbeeld. Hij vroeg een model een proefje te maken met het testframework TUnit in een applicatie vol xUnit. Het model antwoordde vol overtuiging dat het gelukt was, maar had er alleen xUnit van gemaakt.

De behandeling bestaat uit drie medicijnen:

Informatie-injectie: laat de agent eerst documentatie ophalen, bijvoorbeeld via de Context7 MCP-server, die actuele documentatie van frameworks levert.
Skills als fundament: een skill is lazy loaded context. De instructies worden pas geladen als de agent iets gaat doen wat er semantisch op aansluit. Dat bespaart kosten en het heeft een tweede voordeel door het lost in the middle-effect. Een LLM weegt het begin en het einde van het context window het zwaarst. Een skill komt achteraan te staan, dus de meest relevante instructies staan op de beste plek. Het effect kwam met een U-vormige curve uit het gelijknamige paper: informatie aan het begin en einde van het venster wordt het best onthouden.
Ask questions activation: geef de agent de instructie om bij onduidelijkheden eerst vragen te stellen. De plan agent in VS Code doet dit bijvoorbeeld standaard.

Een schematisch voorbeeld van zo’n skill:


---
name: tunit
description: Gebruik deze skill bij alles wat met TUnit te maken heeft
---

## Instructions

### 1. Fetch the latest TUnit docs
Use the context7 MCP tools in sequence:
1. Resolve the library ID: call the resolve-library-id tool with the
   query "TUnit". Pick the result for the TUnit testing framework
   (not unrelated packages).
2. Get the docs: call the get-library-docs tool.

### 2. Write or migrate the tests
Do this only after step 1, based on that documentation.

In Rubens demo stonden hier de volledige toolnamen van de Context7 MCP-server in. Daarmee prik je precies vast welke tool de agent moet aanroepen.

Patiënt 2: Billy Bernard (zegt dat het klaar is, maar het werkt niet)

Billy is enthousiast en roept dat hij klaar is, maar het resultaat is slordig en vol bugs. Zijn diagnose is een tokenburnout. Hier trok het publiek een andere conclusie dan Ruben: 17 stemmen gingen naar “context infection” en maar 6 naar token burnout. De oorzaak zijn twee verschijnselen:

Context anxiety: agents die weten hoe vol hun context window is, worden angstig dat ze hun doel niet halen en gaan slechter presteren. Ruben noemt het een midlifecrisis van de agent. Hij liet een citaat zien uit onderzoek waarin een model taken afkapte of onaf liet terwijl het nog genoeg ruimte had.
Context rot: hoe meer tokens in de context, hoe slechter het resultaat, want de kans om het juiste stukje informatie te vinden wordt kleiner. Hij toonde een grafiek van Chroma Research waarin de prestaties van onder meer Claude Sonnet 4, GPT-4.1, Qwen3-32B en Gemini 2.5 Flash dalen naarmate de invoer langer wordt.

De behandeling heet verdeel en heers. Knip het werk op in kleine stukken, zodat elk stuk minder context nodig heeft:

Gebruik een gestructureerd proces met aparte sessies: specificeren, technisch ontwerpen, implementeren en controleren. Dit heet spec-driven development. Er zijn meerdere varianten, zoals Spec Kit van Microsoft voor grote projecten of simpelweg plan mode in VS Code. Je kunt ook de implementatie zelf opknippen, bijvoorbeeld eerst de domeinklassen, dan de tests.
Gebruik een groter model met een groter context window, zodat je minder snel tegen de limiet aanloopt.
Zet de agent op dieet (de “Ozempic-aanpak”) en houd het context window slank. Wie voor de lol twintig MCP-servers aan laat staan, begint al met tienduizenden tokens voordat de agent één stap heeft gezet.

Het proces bestaat uit vier stappen: Specify (functionaliteit), Plan (architectuur), Implement (code) en Verify (review). Zo ziet de template voor een feature-spec eruit:


Feature specs live at: .github/specs/<kebab-case-name>/spec.md
Write in brief sentences. Prefer specific, testable wording.

RULES: Never include technical implementation details
(e.g. "calls API X", "database table Y"). Instead, describe what the
user does and what they see, and how the system responds in
observable terms.

# Feature: <feature-name>
## 1) Goal (Why)
### Problem statement
<What user problem are we solving?>
### Who feels it most
<Which users are impacted most, and in what situation?>

De skill die deze spec schrijft, sluit af met een review door een subagent:


---
name: specify-feature
description: Generates a comprehensive functional description of a feature.
---

## Role and Goal
You are a senior analyst and project manager with 20 years of experience
responsible for writing thorough, complete feature specifications.

## Instructions
1. Step 1
2. Step 2
...
7. Use #runSubagent tool to spawn a subagent (default agent type).
   Ask the subagent to check the generated spec.md against the template.
   It should detect things that are missing and things that are
   undesired like technical details.

Het werk wordt daarna opgeknipt in werkpakketten, bijvoorbeeld “Implement part 1 of the plan”, met een todo-lijst van zeven items: eerst de domeinentiteiten, dan de DbSets, de sleutels en de cascade-delete-relaties. Bij het controleren van het technisch plan gaf de subagent een duidelijk FAIL: goede structuur en dekking, maar te veel codefragmenten voor het abstractieniveau van de template.

Patiënt 3: Johnny Jason (de puber)

Johnny maakt zijn eigen versie van de taak, doet dingen buiten zijn opdracht en verwijdert bestanden die in de weg zitten. De diagnose: puberteit. Ruben merkte op dat de “non-negotiable therapy” (in hoofdletters schrijven dat de agent iets niet mag) populair was bij het publiek. Volgens hem werkt dat in de praktijk slecht en is het vooral een kenmerk van AI-gegenereerde skills en agents. Zijn drie medicijnen:

Structuring serum: LLM’s houden zich veel beter aan een formaat als dat in een gestructureerde taal staat, zoals JSON, XML of Markdown. Ze zijn getraind op talen waarin één ontbrekende komma of slash alles kapot maakt. Overweeg ook om de agent een script te laten genereren, bijvoorbeeld in PowerShell, dat deterministisch draait.
Extra eyes elixir: dit was Rubens belangrijkste tip. Laat aan het eind van elke skill of workflow een nieuwe agent het werk van de eerste reviewen. De eerste agent heeft een context window vol interne dialoog en is overtuigd dat hij goed werk heeft geleverd. De tweede begint met een schone lei en is kritisch. In VS Code regel je dit met de run subagent-tool. In zijn voorbeeld ving de reviewer meteen op dat er code in een functioneel ontwerp stond, iets wat agents steevast proberen. Anthropic publiceerde recent dat ze dit in hun eigen werkprocessen ook veel toepassen.
Healing hooks: hooks zijn scripts die op vaste momenten in het werkproces van de agent draaien, zoals bij de start of het einde van een sessie of vlak voor een tool call. Zo kun je een poging om bepaalde bestanden aan te raken afwijzen en een bericht terugsturen naar de agent. Dit is geen statistiek meer maar gewoon software die altijd hetzelfde uitvoert.

Zo ziet de uitkomst van een hook er in de praktijk uit, bijvoorbeeld voor een PreToolUse-hook:


{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "Destructive command blocked by policy",
    "additionalContext": "User has read-only access to production files"
  }
}

Het script dat dit teruggeeft, is gewone software. De agent krijgt de reden terug en kan zijn aanpak bijstellen. En vergeet jezelf niet: ook jij als mens kunt aan het eind goedkeuren.

De live operatie

Johnny moest release notes maken uit een Jira-bord en de git-commits, met alleen features die klaar zijn (status Done en gecommit), inclusief Jira-nummer en titel. De agent file van de eerste, zieke versie zag er zo uit:


name: Johnny
description: Johnny.

## Role
You are a release manager for the Conduit project.

## Goal
Your goal is to write consistent release notes for the Conduit project.

## Instructions
Write release notes.
IMPORTANT: ONLY include features that are completed.
IMPORTANT: ONLY include the jira number and title for each feature.

Met die nette rol en instructie in hoofdletters ging het mis. Hij nam een bugfix mee die nog in progress stond en gebruikte de Jira-titels niet.

Ruben paste vier dingen toe:

Een subagent-review aan het eind.
Het outputformat in een gestructureerde taal, voor consistente release notes.
Explicieter prompten: pak alle commits, controleer de datum en gebruik daarna precies deze Jira-tool.
Tools vastprikken en afschermen. Veel MCP-servers hebben meerdere tools voor bijna hetzelfde. Heb je een tool-aanroeppad dat werkt, noem dat dan expliciet en laat de andere tools weg uit de whitelist.

De genezen agent (johnny-cured) kreeg een expliciet model, een whitelist van tools (alleen de Jira-tools voor getJiraIssue en searchJiraIssuesUsingJql, een paar terminal-tools, read, agent en todo), een vast outputformat en een validatiestap:


5. Write your <answer> in the following format:
   # Release Notes
   - CON-<number>: <title>
   - CON-<number>: <title>
6. Call a subagent (normal agent type) that validates whether your output
   is in the correct format and if it includes only stories that are in
   "Done" status and have a commit associated with them. If the validation
   fails, fix the issues and validate again until it succeeds.

De tweede run was raak. De agent raadpleegde Jira, haalde de stories op en maakte de notes in het afgesproken format. Hij liet CON-2 weg (wel een commit op master, maar in Jira nog In Progress) en CON-5 (in Jira Done, maar geen commit op master die ernaar verwijst). Hij meldde ook dat een subagent de notes tegen de commits en Jira-statussen had gecontroleerd. De uitgewerkte agent files deelt Ruben via een git-repo.

De boodschap: puzzel in de context

Tot slot sprak Ruben de zorg aan dat we werk wegdelegeren dat we vroeger leuk vonden. Zijn antwoord: puzzelen kan nog steeds, alleen in een ander vakgebied. Het gaat nu om de inrichting van je context in plaats van je code. Waar je eerst een method extraheerde, extraheer je nu een skill. En hoe deel je context over teams heen? Het zijn dezelfde problemen op een hoger niveau.

Dus heb je een agent die niet doet wat je wilt: gooi hem niet weg, maar breng hem naar de kliniek. De zaal ging naar huis met een certificaat in een volledig ongereguleerd vakgebied. De QR-code naar GitHub stond op de laatste slide, naast het certificaat voor genaiskunde met een wassen zegel in de vorm van een robotgezicht.

Afsluiting van de avond

De organisatie bedankte de sprekers en gastheer Covadis met een Cloud & Code Oost-trofee en Covadis bedankte op zijn beurt de sprekers met een bierpakket. Aan de borrel hing een tafel vol stickers en goodies, ook van .NET Conf. De organisatoren zijn benieuwd naar de eerste persoon die zo’n sticker op zijn laptop plakt en dat deelt op de socials.

Wil je de volgende editie niet missen of zelf een talk geven? Houd Meetup.com en de socials van Cloud & Code Oost in de gaten.