AI Coding Summit Berlin

In this workshop, I'll guide participants through a decision framework for Claude Code's orchestration tools. Most people already use two or three of them and guess about the rest.

A founder spent around eight weeks of his spare time adding 349,000 AI-written lines to a sports platform we had built. On the surface it worked. Underneath, anyone signed in could read strangers' private chats, and the tests that came with it passed. Three of us could not review our way through it.

Agents write faster than any team reviews, and an AI marking its own homework gives itself a pass. The harness is the scaffolding in your repository that an agent works inside, so every session inherits your standards and every change meets checks the model doesn't control. In three hours you build three of its five layers:

Repository instructions every agent session picks up, whichever tool it runs in
Deterministic enforcement: your team's rules as custom checks that fail the build (analyzers, lint rules, strict types, post-edit and pre-commit hooks, CI that blocks the merge), with error messages the agent has to fix before it continues
A validation loop the model doesn't grade: tests written from the spec by a session that never saw the code, and a check that calls every endpoint as every kind of user
You work on a deliberately vibe-coded club app, then spend the last half hour on your own repository. Every merge faces one test: could you debug it half asleep at three in the morning? If not, it doesn't merge.

What participants take away

- Structure a repository so any coding agent inherits your standards
- Move enforcement into deterministic tooling that gives agents immediate, non-negotiable feedback
- Validate agent work with checks the model doesn't grade: tests from the spec, and every endpoint called as every kind of user
- Hold your next merge to a gate you can defend at three in the morning
Practical exercises

1. Run the task with no harness, find the defects in your own run, and see that the agent's tests pass
2. Write house rules as repository instructions and re-run a probe task
3. Write a custom lint rule (ESLint in the lab; a Roslyn analyzer or your stack's equivalent at home) that fails the build when code changes a balance outside the ledger, with an error message written for the model; wire it to a post-edit hook and watch the agent fix its own code
4. Break the hook on purpose and watch the edit go through: hooks fail open
5. Have a second session that never saw the code write tests from the spec, and run a check that calls every endpoint as every kind of user; it finds the hole the agent added and one nobody touched
6. In your own repository: your team's most repeated review comment as a custom lint rule or analyzer that fails the build, or one spec-first test for code nobody fully owns

Prerequisites

A laptop with Claude Code, Codex or a comparable coding agent installed and authenticated, and the lab repository cloned before the session; we'll send a setup check in advance. Bring a repository you actually work in for the last half hour.

AI can generate a React feature in minutes, but getting it to production quality is a different story. In this advanced, hands-on workshop we go beyond simple prompting and build a real React application with Cursor AI, the way professional teams do it.

You will learn how to:
- Set up Cursor for a real codebase with project rules, context and reusable prompts
- Plan and build features with Cursor's Agent while keeping full control over architecture and code quality
- Generate and maintain tests, types and documentation with AI
- Review AI-generated code for security issues, performance problems and hidden bugs
- Refactor and scale an existing React codebase safely with AI assistance
- Prepare the application for production with CI checks, linting and deployment best practices

By the end of the workshop you will have a practical workflow for using AI to ship React features faster without sacrificing quality, security or maintainability.

Level: intermediate to advanced. Basic React and TypeScript knowledge is recommended.

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline:

1. The failing agent: why it breaks, and why it claims success anyway
2. The agent loop, built up from an empty loop
3. A tool registry and context management
4. Guardrails, context compression and retries that hold whichever model sits underneath
5. Deterministic verification, so the agent fails honestly instead of claiming success
6. Moving secrets and fragile steps, like login, out of the model and into the harness
7. A harness plan for the agents you're building