Technical Talks

Point two coding agents at one repository and they will quietly destroy each other's work — not because either wrote bad code, but because a working directory is shared mutable state. `git worktree` has fixed that since 2015: one checkout per agent, one object store, and with separate ports and its own testcontainer each agent gets an environment instead of a folder. So you scale up — nine agents, three screens — and the bottleneck moves. Every branch is green against a `main` that has since moved, and you rebase, retest, and lose the race again. This talk follows that escalation to the merge queue, and then past it: the queue becomes the next bottleneck, so you stop gating every merge, and you stop reading how the code got written.

Vector RAG from the ground up: why an LLM doesn't know your company's documents, how chunking and embeddings turn text into a map of meaning, and how retrieval puts the right pieces back in the prompt. Built around a real use case — consultants asking itenium anything — with four questions the naive pipeline gets wrong, and one that no retriever ever reaches.

You've met skills, agents, and hooks — now make Claude Code your own. Turn the knobs (settings, context engineering, models, permissions), author each primitive around one principle — the description is the interface — then compose them into installable plugins you pull from a marketplace and ship to your team.

What changes when AI does the typing. A practical tour of context engineering (the lever that moves you up the AI maturity ladder), compounding engineering (each session writes the playbook the next agent reads), and harness engineering (deterministic guardrails the model can't talk its way out of). A live Superpowers demo runs on a real modernization in parallel — we check in at the end.

A guided tour through Chris Richardson's *Microservices Patterns*: when (not) to break up the monolith, what changes when in-process calls become network hops, and the patterns that keep a distributed system from collapsing into a distributed monolith. Covers Sagas, API Gateways, CQRS, the Service Registry, and the operational reality of running many small services in production.

Why do we write tests? What should we test — and what not? This session covers everything from the testing pyramid and the FIRST principles to code coverage pitfalls, mutation testing, and dealing with legacy code. We'll break the cycle of fear that keeps teams from refactoring and explore how TDD can change the way you design software.

As AI coding assistants gain access to our codebases, terminals, and databases, we're one prompt injection away from disaster. This session explores the "Lethal Trifecta" — the architectural flaw that makes AI systems fundamentally vulnerable — through real-world breaches including zero-click data exfiltration and RCE via code comments. You'll learn attack patterns (tool poisoning, multimodal injections, jailbreaking) and defensive strategies including tool isolation and prompt injection detection. Walk away knowing which AI integrations are safe and which are ticking time bombs.

An introduction to dependency-inverted architectures. Starting from the classic N-Tier/Multitier approach, we explore its strengths and limitations, then move to Ports-and-Adapters, Hexagonal, and Onion Architecture — showing how they all center the domain and manage complexity through dependency inversion.

A practical and pragmatic theoretical session on Event Sourcing and CQRS (Command Query Responsibility Segregation). Both offer tremendously powerful features out of the box but also bring with them a whole slew of new challenges. A cautionary tale.

Introduction to the itenium Architecture track: what is a software architect, what kinds exist, what tasks they perform, and what good architecture means. Covers non-functional requirements, common pitfalls like over-engineering and ivory tower frameworks.