3-Week Program

The Agentic Engineer Course

Go from a messy idea to a shipped, event-sourced system - built with AI agents that work from a complete spec, not a vague prompt. Three weeks: Event Modeling, Event Sourcing & Slices, and AI Engineering.

Join the Wait List Book a Call

First Cohort starting in September 2026.

Delivered by Nebulit.

Why This Course

Code Generation Isn't the Bottleneck Anymore

Why: AI agents can already write code faster than any team. What most teams are missing is a spec complete enough - and a process disciplined enough - for that code to be correct, testable, and production-grade on the first pass.

This course builds that foundation from the ground up: model the domain, turn the model into a working event-sourced system, then hand slices of it to autonomous agents and watch them ship.

Three Weeks, One Delivery Pipeline

From Model to Shipped System

Each week builds directly on the last - the model you build in Week 1 becomes the system you build in Week 2, and the substrate your agents work from in Week 3.

🗺️

Week 1 - Event Modeling

Build a model of a real feature that's honest about how the system actually behaves - events, commands, read models, storyboards, business rules, and slices.

  • The 4 building blocks & 4 core patterns
  • Timeline, storyboards, Given-When-Then scenarios
  • Slicing the model into estimable work
⚙️

Week 2 - Event Sourcing & Slices

Turn one slice of the Week 1 model into a working, tested, event-sourced vertical slice - command handler, event, and read-model projection.

  • Event Sourcing fundamentals & CQRS in practice
  • Entities, aggregates, and process managers
  • Tests derived directly from the model's scenarios
🤖

Week 3 - AI Engineering

Stop treating AI as a code-completion tool. Set up an agent loop that reads slices from the model and ships them - with guardrails, not babysitting.

  • Spec-driven development & the agent loop
  • Setting up the harness, slice status as a task queue
  • Guardrails, verification, and engineering trust
The Curriculum

Day by Day

Five days a week, each building on the last, working the whole time against one running example you bring from your own work.

Week 1 - Event Modeling

1 Motivation & the 4 Building Blocks Mon
Name the 4 building blocks (Events, Commands, Read Models, external systems) and the 4 core patterns, and point them out on an example model. Critique a flawed model in pairs; sketch the first 3 events of your own running example.
2 Timeline & Strategic Event Modeling Tue
Build a chronological timeline for your example and check you're solving the right problem, not just the how. Extend the running example into a full user journey.
3 Screens, Storyboards & Mapping Wed
Give every event/command on the timeline a wireframe or external trigger, and translate the model into your team's existing process vocabulary (Scrum, BPMN, UML). Storyboard 3 screens for the running example.
4 Business Rules, Scenarios & Slicing Thu
Extract Given-When-Then scenarios from a "hidden business rule" transcript, then slice the running example into delivery-sized units.
5 Group Exercise - Model a Feature End-to-End Fri
Model a new feature live as a group, from a messy, stakeholder-interview-style verbal description ("model as you speak"). Present and peer-review each other's models.

Week 2 - Event Sourcing and Slices

1 Event Sourcing Fundamentals & CQRS Mon
Explain Event Sourcing as "the simplest thing that could work," and correctly separate a command path from a query path for one slice. Clone and run a minimal working example.
2 The Slice as the Unit of Delivery Tue
Scaffold one slice end-to-end - command handler, event, read model - even if empty. Wire the command and event handler skeletons from a template.
3 Entities, Aggregates & Process Managers Wed
Enforce the slice's entity invariant correctly, and decide whether your own example needs a process manager - and why most don't.
4 Tests, Projections & Schema Versioning Thu
Convert Week 1 scenarios into executable Given-When-Then tests, then build the read-model projection and confirm it updates correctly.
5 Event Store vs. Kafka & Group Exercise Fri
Finish and demo your slice end-to-end, and fill out a decision matrix for event store vs. Kafka (or both) in your own context.

Week 3 - AI Engineering

1 Spec-Driven Development & the Agent Loop Mon
Run the same feature through a vague prompt and a full spec, and compare the diff. Understand why a complete spec - not a prompt - is what makes agent-generated code production-grade, and how the RALPH loop works.
2 Setting Up the Harness Tue
Wire up a harness where a slice's status change triggers an agent to pick it up. Dry-run with a trivial slice to confirm the loop fires end-to-end.
3 Loop Engineering in Practice Wed
Run a deliberately under-specified slice through the loop, watch it fail or get blocked, fix the spec - not the prompt - and re-run.
4 Guardrails, Verification & Engineering Trust Thu
Add 2-3 guardrails to your harness and deliberately trigger one to confirm the loop respects it instead of arguing past it. Articulate what "trust the spec, not the prompt" means in practice.
5 Group Exercise - Build the Model Fri
Take a new feature from idea to a complete Event Model, hand it to the harness, and observe/report the result as a group - no manual prompting after kickoff.
Who It's For

Built for Engineers Who Ship

Why: the course assumes you'll walk away with a real, working slice of your own system - not a set of slides about agentic AI.

👩‍💻

Engineering Teams

Learn a repeatable pipeline from domain model to shipped, tested code - one your whole team can run again on the next feature.

🏗️

Architects & Tech Leads

Design the harness and guardrails that let agents work autonomously on your codebase without drifting from the spec.

🚀

Teams Adopting AI Agents

Move past ad-hoc prompting toward a process where the spec - not the prompt - is what makes agent output trustworthy.

Interested in the Agentic Engineer Course?

Book a call to talk through format, dates, and pricing for your team.

Book a Call See Event Modeling Workshops