Your developers already use AI. Teach them to turn it into a system.
One hands-on day where your team learns to work with AI agents the way the best teams do: think first, then delegate, with one shared way of working and checks that safeguard quality. In your own codebase.
Scroll to see it
The potential gap
your team without AI·full potential with AI·with AI, on your own
Conceptual model for illustration, not a measurement. What is achievable varies by team and codebase.
Before we start
How big is your development team?
Anyone can build fast. Building tall is another story.
Every block is a change. Without a system, debt piles up until it all falls over. With a system you build tall, fast and at scale, and everything fits together.
AI is already here. The payoff isn't yet.
What we keep hearing from development teams, even when everyone already uses AI every day.
Review hell and a growing PR backlog
Merge requests are too big to review comfortably, sit open for days, and code owners keep getting pulled out of their work.
What changesAgents review locally before you push. Smaller, cleaner PRs that get through review faster.
The knowledge lives in a few heads
Domain knowledge, edge cases and pitfalls aren't written down anywhere. New colleagues need weeks, and when the expert is on holiday, work stalls.
What changesYou capture that knowledge where both the agent and the team use it. The system gets smarter every week.
Everyone does it their own way
One developer builds whole features with AI, another gave up after two bad prompts. There's no shared way of working, so no shared lessons either.
What changesOne way of working for the whole team, that everyone can follow and improve together.
Ship faster, without giving up quality
If you don't ship fast, you get overtaken. But vibe coding your way to production isn't an option: you're still responsible for the code.
What changesThink first, then delegate, with checks that safeguard quality.
The thinking doesn't disappear. It shifts.
AI takes over the details. That doesn't make your developers redundant, it lifts them a level up: from writing lines of code to deciding what gets built and why.
- DetailsArchitecture
The agent writes the code. Your developer thinks about the shape of the system, the trade-offs and the pitfalls. An architect who can build in any domain.
- While buildingUp front
The real work happens before the first line of code: sparring with the agent until you're aligned, then capturing it in a plan. The better you think up front, the less the agent has to guess along the way.
- Each to their ownOne way of working
The whole team works with agents the same way. So good results become repeatable instead of luck.
What a task looks like
- 1
Think it through
You + agent
Talk through the idea, explore options and risks until it's right.
- 2
Plan
You approve
A plan that pins down exactly what gets built, and what doesn't.
- 3
Build
Agent
Executes on its own, within your codebase's conventions.
- 4
Review
Agent + you
A fresh pair of eyes on the result. You decide what goes in.
This only works with real knowledge underneath. AI amplifies a good developer's thinking, it doesn't replace it. That's why we teach principles, not tricks.
The best engineering teams already work this way.
Not with better models than you have, but with a system around them. Agents that plan, build, test and open PRs, within clear boundaries.
Stripe
1,300+
merged pull requests a week at Stripe, written entirely by agents
No hand-written code in those PRs, yet every one is reviewed by a human. In the codebase behind more than a trillion dollars in payments a year.
Airbnb
Used LLMs to migrate about 3,500 test files in 6 weeks. By hand, it was estimated at a year and a half.
Shopify
Built Roast: an open-source engine that breaks AI work into structured, repeatable steps.
GitHub
Uses its own Copilot coding agent on its own codebase: assign an issue, the agent writes the code and opens a PR for review.
Google
75% of all new code at Google is now AI-generated and approved by engineers, according to CEO Sundar Pichai.
From scattered prompts to a way of working that improves every week.
Six principles that keep working as the models get better. We tailor the details to your team and codebase.
Think first, then build
Spar with the agent until you're aligned, then capture it in a plan. Only then does building start.
Agents that understand your code
How to make an agent understand how your software fits together, so no session starts from zero.
Capture what works
Good approaches don't belong in someone's chat history. One shared way of working, with each codebase's own conventions on top.
Delegate without losing control
You make the decisions, the agent executes. When do you let go, and when do you go back to the drawing board?
Safeguard quality
Let machines check what machines can check, so human review is about what actually matters.
Improve the system, not just the code
Every agent mistake is information. You learn to fix not just the code but the way of working, so it goes right next time.
Clear boundaries from the very first prompt.
For larger organizations this is often the first question, and rightly so. An agent with access to your codebase needs clear boundaries. Your team learns them from the start.
Agreements before we start
We agree up front which tools, models and accounts are allowed, within your existing policies. Preferably business licenses, where your code isn't used to train models by default. On personal plans, it often is.
No secrets or production data
No API keys, passwords or customer data in a prompt. Reference secrets by variable name, never the value itself. Anonymize data: keep the shape, lose the personal details.
Agents with scoped permissions
What an agent may run on its own is defined explicitly. No access to production, but access to everything it needs to do good work.
Humans decide
Nothing enters the codebase without human review. The agent does the work, your team keeps the responsibility and the control.
Few slides, lots of building.
A full day on-site with your team. First we show how it works, then you get hands-on, and most of the day you work on real cases.
- 1
Show
The principles, and live how an agent takes a task from first idea to review.
- 2
Practice
Hands-on exercises in a prepared codebase, so everyone builds the muscle memory.
- 3
Your own cases
Bring real challenges from your company. We tackle them in your own codebase, with the trainer alongside.
What your team takes home
One shared way of working for the whole team, instead of everyone's own prompts
A first version of your system, right in your own repository
A feel for what agents are and aren't good at, and how to steer them
Quality checks that don't depend on one busy reviewer
A plan to keep growing the system after the workshop
Taught by someone who builds with it every day.
Joppe van der Schoot
Founder, Ebel Tech
Joppe builds with AI agents every day, for clients and for himself. He combines deep technical AI knowledge with business insight, so he speaks the language of both the developer and the CTO.
Good to know
Which tools do we use?
The principles are tool-agnostic. We work with Claude Code, Cursor, GitHub Copilot or Codex, and tailor it to what your team already uses.
Do developers need prior AI experience?
No. We start with a short baseline measurement, so both beginners and developers who already use AI daily join at their own level and get real value out of the day.
Do we really work in our own codebase?
Yes, that's the final and most important part of the day. You choose the cases. Beforehand we agree on data and privacy, and on what can and can't be sent to a model.
Will the trainer see our code?
Only what's needed for the cases you choose, and only on your own machines. We're happy to sign an NDA.
What do we need to prepare?
Laptops with the chosen tool and a business license, plus access to the repository we'll work in. In the run-up we agree on which cases you'll bring.
Does this work on an older or large codebase?
Yes. That's exactly where it pays off to make agents understand how the code fits together. It's one of the principles we focus on.
How many people can join?
Up to 20 participants per session. That way everyone gets enough guidance, including on their own cases.
What does the workshop cost?
The workshop starts from €1,400 excl. VAT. The final price depends on group size and how much preparation your codebase needs; after the intro call you'll receive a tailored proposal.
Is there a follow-up?
Yes. If you'd like help rolling out or further building your system after the workshop, we'll figure out together what fits.
Book an intro call
A no-obligation conversation. We look at where your team stands, what the workshop can do for you and how we tailor it to your codebase.
Prefer direct contact?