Technical Talks

Part 2 of the Dark Factory series. Two coding agents in one checkout quietly destroy each other's work. git worktree gives each agent its own checkout, and with its own ports and testcontainer, its own environment. Scale to 6+ agents and the bottleneck moves: every branch is green against a main that has since moved. Enter the merge queue, until the queue becomes the bottleneck too.

Part 1 of the Dark Factory series, and the boring part: probably where you'll spend more time than on the factory itself. Add every deterministic guardrail in existence — formatters, linters, type checks, automated tests — and turn the knobs to 11. Then the actually tricky part: backpressure that keeps the agent getting work done without going off the rails, and hardening the guardrails themselves, because the agent will try to get around them.

Part 3 of the Dark Factory series. We saw factory blog posts appear in the beginning of 2026 and the big question was "But how???". Turns out that once you have done parts 1 & 2, the factory is suddenly within reach. Expect a slowdown first: you'll have to build the factory, the dashboards, and add more and more autonomous agents that all take over some part of what the human in the loop used to do. Keep watching and tweaking until you feel confident, then turn off the lights.

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.