Agentic Engineering Masterclass in Utrecht

Bring your team in Utrecht through the workflow: who owns plan and review, how you harness paid and open-source coding agents, and how you prove output before merge. Two days. Deterministic delivery. Velocity without breaking the app or the token budget.

View Full Workshop Details Book for Your Team

Why Take This Workshop in Utrecht?

Utrecht is a growing tech city in the heart of the Netherlands with strong connections to Amsterdam's tech ecosystem. The city is home to numerous software companies and a thriving developer community. The Agentic Engineering Masterclass in Utrecht gives your team a shared workflow for AI-assisted work, so it stops being a personal habit and becomes how the squad ships features.

Workshop at a Glance

Duration

2 Days

Format

Remote or On-site

Participants

Up to 12 participants

Price

€650/person / day

What Your Team Will Learn

For engineering leads and developers in large orgs who already ship with AI tools. You leave able to name each person's role, turn agent output into a deterministic loop, and raise velocity without burning tokens or flooding review.

A shared working model: roles for plan, implementation, and review when agents write most of the code
A harness on your repo: memory, skills, and tool choices that stay agent-agnostic
A quality loop that turns 'done' into evidence, so more PRs do not mean more breakage
A way to run more than one agent without stepping on the same working tree or exploding token cost
A written playbook your team can run on Monday

Workshop Curriculum

Two days on your (or a shared) codebase. Day 1 is environment, context, and planning. Day 2 is the quality loop: evidence, parallel work, and cost control before a human looks.

Day 1. Environment, context, and how you plan

The working model: who owns the plan, who owns review, and where agents are allowed to run
Paid and open-source harnesses: Cursor, Claude Code, Codex, OpenCode, and when each fits
Memory files: tiny global prefs, project memory that grows when you correct a mistake
Skills and progressive disclosure: knowledge you only load when the task needs it
Tool ergonomics: CLI vs MCP, token cost, latency, and why random skills can make agents worse
Plan as an artifact you can point at, not a wall of markdown
Hands-on: configure an agent on a real repo and run the first change through the plan

Day 2. Quality pipeline, parallel work, prove the output

When the agent says done: stop reviewing every diff, start reviewing evidence and risk
Quality pipeline: recover intent, rebase, adversarial review in a fresh context, end-to-end proof, docs, PR
Isolation for parallel work: worktrees, lifecycle, and how leads stop holding state in their head
Long-running loops with stop conditions: overnight work on verifiable objectives
Orchestration: one lead session that delegates, so you stay on direction instead of juggling every agent
Team playbook: shared skills, who reviews what, Monday rules for risk-based review
Hands-on: one feature through the workflow, from plan to evidence to PR

Tools & Focus Areas

Paid

Paid harnesses

Cursor, Claude Code, and Codex in practice. Same workflow, different tools. We stay harness-agnostic on purpose.

OSS

Open-source harnesses

OpenCode, Pi, and CLI-first setups so the workflow survives when the best model next month is not the one you bought this month.

Pipeline

Quality pipeline

Memory, skills, plan artifacts, isolated worktrees, adversarial review, and end-to-end evidence before merge.

Your Instructor

Davy Engone

Founder & Software Mentor @ Hackages

Davy has trained 5,000+ engineers. This masterclass is the workflow he is installing on real repos: roles, evidence, and cost control when agents write most of the change.