Defaulting to cloud APIs is no longer the only way to ship AI in iOS apps. This hands-on workshop dives into Apple Foundation Models, moving past theory to build privacy-first AI features directly into native apps.

We will focus on practical implementation: how to actually run these models, customize them for your specific domain, and empower them by providing external tools to enrich context and build truly smart, localized experiences. Requirements: MacBook, Apple Intelligence-compatible iPhone, and basic Swift/Xcode skills.

BIO

The usage of Artificial Intelligence in video game production has immediately sparked controversy linked to the notion of ‘AI sloppiness’ and the risk of undermining the entire creative process.

The workshop, however, aims to demonstrate in practical terms how Artificial Intelligence can be used to streamline prototyping and the range of complex tasks involved in product development.
Starting with the use of Claude Code and related tools, the workshop aims to give the audience a hands-on experience of the practical benefits of using AI in this field.

BIO

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.

BIO

The definition of “Mobile Engineering” is shifting. As we enter the Agentic Era, the bottleneck is no longer writing syntax – it’s architecture, governance, and verification.

This session is for developers and leaders ready to upgrade their mental models and their tech stacks. We will examine real-world “Agentic Patterns” that allow small mobile teams to ship with the velocity of giants.

BIO

LinkedIn

LLMs don’t fail because they “lack intelligence.” They fail because we keep asking them to play games whose rules we never wrote down. Wittgenstein’s idea of language games offers a sharper mental model: meaning doesn’t live in definitions, but in use—and use is governed by shared practices, context, and what counts as a correct move.

This talk treats prompts, tools, and RAG as the rulebook that turns fluent text into dependable behavior. Instead of “better prompts,” we focus on clearer games: intent, constraints, allowed moves, and explicit output contracts. We’ll explore why hallucinations and prompt drift are often not “bugs” in the model, but mismatches between the game we think we’re playing and the one we actually set up—and how lightweight, rule-based evaluations can catch that gap before production does. 

BIO

LinkedIn

Vibe coding has brought app development to everyone — but is it adequate for professional-level work? And what happens when you move beyond the vibe, into more structured, agentic approaches?
We’ll walk through the spectrum of AI-assisted development, from free-form generation to spec-driven workflows, with a clear goal in mind: understanding what it takes to produce enterprise-grade software with agentic tools.
Along the way we’ll cover predictability and consistency across a codebase, the current limits of today’s tools, and the gap between a working prototype and code you’d actually ship.

BIO

LinkedIn

Here’s the problem with generic AI assistants: a senior engineer asks “How do I deploy this service?” and gets the same tutorial everyone else gets. The AI doesn’t know how YOUR team actually operates – your deployment workflow, your infrastructure decisions, or the lessons you learned when production went down at 3am.

This talk demonstrates how to build AI systems that work the way your experts actually work – encoding the step-by-step processes, decision-making patterns, and operational knowledge that typically live only in senior developers’ heads.

You’ll see working examples of AI systems that mimic how experts operate across different domains – from technical workflows to content creation to cross-team processes. The key isn’t what they automate, but how they capture and reproduce expert methodology.

The Strategic Imperative:
Generic AI tools are a commodity – everyone gets the same answers from ChatGPT and Copilot. The competitive advantage comes from AI that knows how YOUR organization operates. This matters when tribal knowledge walks out the door, onboarding takes months, and “how we do things” lives in Slack threads and senior developers’ heads.

Embracing AI means making it personal – encoding your team’s operational expertise into shareable, scalable systems.

Lessons Learned:
✓ When encoding workflows adds value vs. when traditional automation wins
✓ What I over-engineered and regret
✓ Patterns for capturing operational expertise without maintenance nightmares
✓ Real constraints and trade-offs from daily use

Attendees leave with live demonstrations, GitHub repositories, and a framework for deciding when personalized AI systems make sense vs. when generic tools are the right choice.

BIO

LinkedIn | Github

ViewModels are at the heart of modern Android and KMP apps, and they come with hidden performance traps most teams discover too late. Lifecycle mismanagement, scope leaks, bad memory patterns, dependency resolution overhead: these issues are hard to trace in production, and AI-assisted development makes them worse. More code ships faster, abstractions multiply, and ViewModel problems become invisible until users are already impacted.

In this hands-on workshop, we’ll debug real ViewModel performance scenarios together, using Koin and Kotzilla to detect issues at the component level without manual instrumentation. You’ll see how DI-based observability gives AI agents the architectural context they need to go from code generator to diagnostic partner.

Agenda:
Intro (10 min) — The ViewModel performance trap: what AI-assisted development changes and why
Lab 1 (20 min) — Spot common issues in a sample app: scope leaks, lifecycle mismanagement, resolution overhead
Lab 2 (25 min) — Instrument with Koin + Kotzilla: component-level detection, no manual logging
Lab 3 (25 min) — Bring AI into the loop: architectural context as a diagnostic lever
Wrap-up (10 min) — Patterns to take home, Q&A

Prerequisites:
– Kotlin experience (intermediate level minimum)
– Familiarity with Android or KMP development
– Basic knowledge of ViewModel and Jetpack Lifecycle concepts
– Koin or another DI framework used in at least one project
– Laptop with Android Studio installed and a working Gradle setup
– Sample project provided in advance (GitHub link shared before the event)

BIO

Agentic AI is redefining coding by shifting the developer’s role from writing every instruction to specifying intent, constraints, and expected outcomes. In this new landscape, Spec-Driven Development becomes essential: specifications guide AI agents in generating, testing, and refining software with greater reliability and control.

This presentation explores how coding is evolving from implementation-centric practice to specification-centered engineering, and why the future of software development depends on designing precise, verifiable specs as the foundation for AI-assisted systems.

BIO

On-device AI is finally becoming usable for everyday mobile development on iOS and Android. Instead of treating it like magic, this talk takes a practical look at what it actually means to run intelligence locally on a user’s device. We will walk through how to get started on both platforms, what the current tooling looks like, where things work well, and where the real limitations still are.

From there, we shift into the product and UX side of the conversation. Running models on-device opens the door to a new class of user experience improvements, but only if they are integrated thoughtfully into real user flows. We will discuss how to think about these opportunities, what makes an AI enhancement genuinely useful, and how to avoid adding clever features that do not meaningfully help users.

We will go some real life examples and scenarios where we leveraged on-device AI to provide the end user with a better experience all around.

A big part of the challenge is trust. AI systems are probabilistic by nature, which means you are often shipping behavior that is not correct one hundred percent of the time. We will cover practical ways to test these systems, design appropriate guardrails, and roll out features responsibly so users stay confident in what your app is doing.

The goal of this session is to give teams a clear, realistic view of the on-device AI landscape on mobile today, along with concrete guidance for turning the technology into user experiences that feel fast, helpful, and dependable in the real world.

BIO

AI generates code faster than ever. But thirty years of software engineering crises tell us the same story: every time we confuse producing with building, we lose meaning. And every time, a movement brings it back.

Agile restored the why (building software for people whose needs change). Craftsmanship and XP restored the how (TDD, clean code, the discipline behind quality). DDD and Clean Architecture restored the what (modeling the business domain, not just stacking features). Each time, the industry rediscovered that the real value of our craft lies beyond code production.

Today, AI is pushing us toward a new crisis. Not technical, but architectural. When code is nearly free, “good enough” becomes invisible, and technical debt compounds at the speed of light.

Drawing from 18 years of building software, creating Koin (used by 25% of native Android apps), and running Kotzilla (where we both build with AI and build tools for engineers navigating the same challenge), I’ll show why architecture and domain modeling have never mattered more. Then I’ll get practical: how do you leverage architectural context to drive development in the AI era? Using dependency injection as a concrete example, I’ll show how making your architecture observable gives both developers and AI agents the context they need to make decisions that hold up over time.

BIO

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.

BIO

AI models are increasingly trusted to make decisions, from detecting tumors in medical scans to powering fraud detection, autonomous systems, and content moderation. But what if the model itself has been quietly manipulated during training?

Backdoor attacks are one of the most subtle and dangerous threats to modern machine learning. By injecting carefully crafted poisoned data into the training process, an attacker can implant hidden behaviors into a model. The system performs normally in everyday conditions, maintaining high accuracy and passing validation tests, until a specific trigger appears. Then, it predictably fails in a way chosen by the attacker.

In this talk, we explore how backdoor attacks work, how they impact both traditional centralized training pipelines and distributed approaches such as federated learning, where multiple parties collaboratively train models, why these threats matter in practice, and what can be done to build AI systems that are not only accurate, but trustworthy. We discuss these issues using the medical imaging domain as an example, where compromised predictions can directly affect patient safety, while highlighting how the same vulnerabilities extend to any AI system trained on shared, outsourced, or third-party data.

BIO

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.

BIO

LinkedIn | Github

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.

BIO