Agenda

This workshop is a pragmatic, opinionated approach to agentic development for solo developers and small teams. It starts from one rule: document first, agent oriented. Documentation and code evolve together, each change to one carries a change to the other, so the project always explains itself to the agents working on it. The docs are organized to be self-discovered and self-maintained, optimized for context handling.

We’ll work hands-on on a sample project, and we’ll let it evolve. You’ll understand how to make the documentation self-organizing, and complement it with a smart use of skills. Finally, you’ll adopt a workflow that is flexible in how you use it and rigid in its steps: a small fixed sequence of stages that keeps agents on track without turning into process overhead.

You’ll leave with an example approach that you can adapt to your own projects, and increased awareness of how agents behave, so you can make more efficient use of the tools at your disposal.

Takeaways:

• A good strategy to organize a project and its documentation.
• A self-organizing approach to docs that resists drift.
• Some examples of effective workflows.
• A better understanding of agentic coding, and not only coding

The way we build software has changed. Today, the most successful developers aren’t just writing code, they are orchestrating AI tools and agents to build better and faster. This hands-on session is a deep dive into this modern “Builder Stack”, where you will learn how to build with a variety of tools in the Google ecosystem.

Come to this session if you want to spend less time configuring and more time creating. We’ll guide you through a complete development lifecycle, from prototyping an idea, to generating a beautiful UI, building AI features, and integrating a secure, scalable backend.

The traditional software development lifecycle is undergoing a seismic shift. For years, the industry goal has been to transition from siloed, “standard” engineering teams to autonomous End-to-End (E2E) teams that own their products from inception to production. Today, the introduction of advanced AI tooling is forcing an entirely new evolution: the leap to the Agentic E2E Engineering Team.

We will explore what it means to build, run, and scale an engineering team where AI is not just a coding assistant, but an active, integrated agent across the entire SDLC. We will map out the evolutionary journey of engineering teams and provide a practical blueprint for supercharging your team’s workflows using AI capabilities.

We will break down how to effectively empower your engineers with AI tools at every critical juncture of the software lifecycle, moving from manual drudgery to high-leverage strategic engineering.

—

Key Areas of Focus Will Include:

• The Evolution of the Engineering Team: Understanding the paradigm shift from Standard -> E2E -> Agentic E2E teams.
• AI-Driven Tech Specs: How to leverage LLMs to move from vague product requirements to robust, clearly defined technical specifications and architectural designs.
• Accelerated Development & MRs: Moving beyond standard autocomplete. We’ll look at agentic coding workflows, and AI-assisted Merge Request (MR) creation.
• Intelligent Code Reviews: Utilizing AI to automate security checks, enforce coding standards, and provide contextual feedback before human eyes ever see the code.
• Pipeline & Deployment: Integrating AI to optimize CI/CD pipelines, predict deployment risks, and automate release notes.
• Observability & The Iteration Cycle: Empowering teams with AI tools for rapid defect triage, log analysis, root-cause identification, and generating automated improvement cycles.

Everyone is automating their labeling pipeline with AI. It seems like the obvious move — faster, cheaper, scalable. At Tecnocad, we did it too. Since December 2025, AI handles 70% of the annotation work for our autonomous perception models. And our model quality dropped significantly.

This talk is the honest account of what happened, why it happened, and what we are doing about it.

Building perception systems for real autonomous vehicles is a fundamentally different challenge from building software that assists humans. You cannot afford hallucinations. Edge cases — the rare, unexpected scenarios that matter most for safety — are exactly what AI labeling gets wrong. We will explain why real-world data acquisition, not synthetic simulation alone, remains irreplaceable for physical AI, and how the quality of your training set is the true performance ceiling of your model.

We will close with our forward-looking bets: the case for a European open data lake for autonomous mobility, and the role of VLMs optimized for reality check.

Coding agents are very effective when they are given relevant, well-defined specs. But give an agent a vague brief and it will not stop to ask questions. Instead, it will fill in the gaps, guessing who the product serves and which trade-offs are acceptable. Inevitably, the result encodes the wrong assumptions.

This talk presents a method to resolve uncertainties before writing effective specs.

We introduce the idea of AI agents as interviewers: using LLMs to iteratively probe the engineer on relevant product decisions and technical trade-offs. We will walk through four levels of interview prompts, ending with a reusable skill that asks one question at a time, offers alternatives, recommends one with its trade-offs, and records every decision in durable repository memory made up of several specialized components: an AGENTS.md guide, a product file, a design file, a domain glossary, and short architecture decision records.

Using a realistic application, we will test each level of interviewing prompt and compare the differences. We will conclude by showing that we do not need to create this kind of skill from scratch: the same pattern appears in GitHub Spec Kit, Matt Pocock’s grill-with-docs, and Compound Engineering.

The audience will leave with a new way to use coding agents, along with practical assets they can try on your next project.

Luxia Pod runs a complete enterprise generative-AI stack on a single NVIDIA DGX Spark, inside the customer’s network and with no runtime dependency on the internet. It targets regulated organisations whose documents cannot leave the building: public administration, healthcare, banking, insurance and document-intensive SMEs.

Documentation used to be the task that slowed teams down: written late, read rarely, stale by the next release. In the agentic era it flips. Agents act on what is written, so docs now decide how fast and how well your AI delivers.

This talk shows how to turn documentation into a driver. We cover the practices that build a virtuous circle, where better docs lead to better agent output and cheaper upkeep, and how to optimize agent context with self-organizing documentation instead of bloated instruction files.

From hands-on experience, you’ll leave with practical tips on how to smartly build and organize documentation for both humans and agents.

Complex linguistic tasks require structured systems to handle ambiguity, context, and grammatical analysis.

We present a Kotlin Multiplatform client-server application for web and mobile that performs Latin text analysis, powered by a multi-agent LLM pipeline executing lexical expansion, contextual disambiguation, grammatical annotation, error detection, and corrective feedback.

The server orchestrates a series of specialized agents:

• Lexical Agent: generates all plausible lemmas and meanings for each token;
• Translation Agent: disambiguates meanings using context;
• Grammar Agent: selects correct morphological forms;
• Critic Agent: identifies potential errors and ambiguities;
• Correction Agent: finalizes annotations with notes and confidence scores;

Attendees will learn how to implement LLM systems that combine semantic reasoning, linguistic expertise, and agent-based self-critique, all within a Ktor client-server architecture that processes Latin texts on demand.

The zero to one phase of an AI startup is where most projects quietly fail. Not because the models are weak, but because the problem is wrong, the scope is off, the team is misbuilt, and execution drifts away from real customer value.

This talk presents a practical zero to one playbook for developers and technical leaders who want to move from builder to founder in the AI era. It connects three elements that are usually treated separately: early product execution, early team design, and what investors actually fund at pre seed and seed stage.

You will learn how to choose a problem customers will pay to solve, how to turn AI capabilities into a real product wedge instead of a demo, how to run tight design partner loops, how to structure a two to four person early team, which roles to delay, and which concrete signals make investors back early technical teams. The session also highlights common early stage failure patterns, including overengineering, premature scaling, and misaligned hires.