Anton is a Developer Advocate at JetBrains, working with Kotlin, IntelliJ IDEA, and AI-driven developer tools. With a background in server-side development, he has spent over a decade building software for developers. A Java Champion since 2014, Anton speaks at conferences, shares insights on the Kotlin YouTube channel, and enjoys exploring new ideas in programming languages, AI-powered tooling, and developer workflows. He’s always experimenting with new tech, looking for ways to make coding more efficient and enjoyable.
AI coding agents are powerful, but they often feel unpredictable. Without structure, they can jump into implementation, miss requirements, or generate code you can’t easily track. Spec-driven development is a practical approach that brings order to this process.
The method is simple: start with clear, high-level requirements, refine them into a detailed development plan, then break that plan into a task list with trackable steps. The AI agent works from these artifacts—requirements.md, plan.md, and tasks.md—instead of ad-hoc prompts. Each step becomes explicit, reviewable, and repeatable.
In this talk, I’ll show how to apply spec-driven development and explain my intuition for this approach. We’ll walk through an example: documenting requirements, generating a plan, creating tasks, and guiding the AI through execution one step at a time. Along the way, you’ll see techniques for controlling workflow, reviewing changes, and avoiding “black box” code generation.
If you’ve tried coding with AI tools but found them chaotic, this session will give you a framework to make them reliable partners.
We are witnessing a fundamental shift in software engineering. As AI
agents become capable of generating entire features, the bottleneck is
no longer writing syntax—it is defining intent. This evolution brings
Spec-Driven Development (SDD) back into the spotlight, not as a
bureaucratic documentation step, but as the primary interface for
software creation.
In this panel, we explore the reality of building software when you're
pair programming with an LLM. We will discuss the architectural
implications of moving from imperative coding to declarative
specifications. How do we define unambiguous requirements for
non-deterministic agents? Does "prompt engineering" evolve into rigorous
system design? Join us to discover if the Spec is truly the new Source
of Truth, or just another layer of abstraction to maintain in a world
where code is becoming a commodity.
Searching for speaker images...