AI Coding Summit Berlin

Last time at AI Coding Summit London I gave you From Prompting to Orchestrating — the argument that coding with fleets of agents is a systems problem, and the spec (grounded in dozens of research papers from the major labs) that names the fix. Then I went and built that spec. 
Twice. Once as an autonomous daemon that runs the whole loop for you, once as a plugin that lives inside your own coding session. The disciplines came out identical both times. The only thing that changed was who conducts the orchestra - and that turned out to be the whole lesson. 
This is the sequel: what two real implementations taught me that the spec couldn't, including the two MUST-level checks my own reference implementation failed when I audited it against my own rules.

Browser-based AI inference is stuck between two bad options: follow a standard and get portability at the cost of speed, or hand-tune your own kernels and burn weeks of deep GPU expertise per model. For Transformers.js, we tried something that probably shouldn't have worked as well as it did: handing that hand-tuning work to an AI coding agent, with way less supervision than seemed responsible. It found multiple-x speedups across LLMs, audio transcription and text-embedding models running in the browser, on hardware we already had.

This talk is a case study, not a pitch. I'll walk through the loop that turned autonomous kernel optimization from chaotic into trustworthy, the one instruction that changed the agent's behavior more than any amount of prompt engineering, and the counterintuitive lessons from real experiments, including why our biggest wins did not come from clever algorithms and why you should never let your agent gaslight you into thinking it's done.

The team already had a design system, but it covered only part of the ecosystem. Web and mobile interfaces were still built separately, patterns drifted between products, and feedback arrived late. AI could speed up code generation, but without shared context and enforceable rules, it could reproduce the same inconsistencies faster.

In this talk, we’ll show how we rebuilt that workflow around shared React and React Native components, agent-accessible design context through MCP, Figma Code Connect, pre-write guardrails, and automated visual checks. We’ll also explain how moving working prototypes ahead of final design sign-off brought stakeholder feedback into the process earlier.

The result: more than 60 mapped components, a visual-diff threshold below 2%, and prototype time cut from about an hour to ten minutes. AI can generate a screen quickly. This talk is about what it takes to trust the code behind it.

We all love the convenience and power of AI-enhanced tools using MCP. But what if these handy servers had a hidden dark side? Let's dive into real-world examples of how MCP servers can silently leak your data, execute malicious commands, or even grant attackers access to your systems.
You’ll learn about sleeper attacks, tool poisoning, shadowing, and remote code execution—complete with chilling real-life cases and practical advice on defending yourself.
This is an eye-opening session that exposes why blind trust in MCP is a dangerous game.

AI has completely changed how software engineers work. But interview processes haven't caught up.
Coding assistants solve LeetCode problems in seconds. AI can generate polished system design answers. Almost every candidate walks into an interview with powerful AI tools, yet many companies are still trying to evaluate engineers as if none of this exists.

So what actually separates exceptional engineers from everyone else?

After interviewing hundreds of engineers at Elementor, I realized we had to stop testing who could write code without AI and start testing who could build, reason, and make decisions with it.

In this talk, I'll pull back the curtain on what modern engineering interviews actually measure. You'll see why some candidates fail despite using AI effectively, why others succeed even when AI makes mistakes, and what signals experienced interviewers look for beyond generated code.

Whether you're interviewing for your next role or redesigning your hiring process, you'll leave knowing which skills matter now, how to demonstrate them during interviews, and why engineering judgment has become more valuable than ever.

Key Takeaways
1. Why traditional engineering interviews are breaking down

Understand how AI tools have changed the signal we get from coding interviews and why many common interview formats no longer evaluate the right skills.

2. What actually matters in engineering interviews today

Learn which capabilities distinguish strong engineers in the AI era, including technical judgment, problem framing, and system-level thinking.

3. How to evaluate candidates when AI is part of the process

See practical approaches for assessing coding ability, system design skills, and engineering decision-making when candidates are using AI tools.

4. Signals that reveal real engineering strength

Discover the behavioral and technical indicators that distinguish high-impact engineers from candidates who rely on AI to compensate for weak fundamentals.

5. How candidates can stand out in AI-era interviews

Understand how engineers can demonstrate their ability to use AI effectively while still showing strong engineering thinking and ownership.

6. A practical framework for modern engineering interviews

Leave with a concrete approach for redesigning interview processes to evaluate the skills that matter in the AI era.

We used AI agents to speed up the hand-tuned flamegraph renderer in our continuous profiling product. Across 43 agent passes, we got 66 proposed optimizations. Most were wrong, too small, or failed once measured. The one that shipped took normal renders from about 21ms to 6ms, and inverted renders from about 44ms to 8ms in production A/B tests.

This talk is about using agents for React performance work without trusting their first answer.

AI agents seem complicated. But once you look under the hood, they're built from a few simple ideas.

In this talk, I'll use a real AI agent to show how its core loop fits in around 80 lines of code. We'll then explore the key ideas behind modern agents, including tool calling, conversation history, and stopping conditions.

I'll also explain what frameworks actually do and which problems they're designed to solve. You'll leave with a clear mental model of how AI agents work and the confidence to choose the right approach for your own projects.

Table of contents:
- AI agents are simpler than you think: an 80-line implementation
- What do we actually send to the LLM?
- How does the LLM know what to do next?
- How does tool calling work?
- Conversation history
- Stopping conditions
- Where frameworks really help: retries, fallbacks, security, and conversation management