Talk 1: Diving into the Heart of LLMs
Large Language Models are one of the fundamental pieces of the modern AI ecosystem - but hardly anyone understands how they actually work. It's a collective challenge, as it's very short sighted to rely your business and architecture on a technology that one might have a hardly any knowledge about.
And it is critical to build a proper understanding, as many good and bad ideas can be evaluated, thanks to seeing how the internals work. At least to some degree.
In this talk we dive into the heart of LLMs - from user's prompt, though tokenizers, embeddings, meeting the core - transformers - and finally output generation.
Talk 2: Fundamental Patterns in Agentic AI Applications
Agentic applications are just applications, though the underlying "service" they're using is somehow specific. There are specific database-related patterns, queue-related patterns etc - not to mention various challenges specific to each. And LLM-based systems are not different!
Both scientists and the industry have already identified some key advantages and issues in practical work with large language models. And hence, there's a handful of very practical patterns that help us overcome the limitations of the context window, issues with the quality of models and their high infrastructure costs. This talk is a distilled SOTA when it comes to practical Agentic Architecture.
Not aimed for beginners or intermediate users; it's designed for those who already have a solid understanding of the language and are ready to level up. We’ll delve deep into several advanced patterns in TypeScript that are battle-tested techniques discovered and honed by the TypeScript community. From low-level details to high-level architecture concepts, get ready to face some of TypeScript's most challenging and exciting features through interactive exercises.
Key Takeaways:
1. Advanced Patterns Primer: Uncover patterns like branded types, value object, and configuring type compatibility that emerge from structural typing.
2. Branded Types: Learn to provide specific domain-related operations that don't easily interfere with primitives - and leverage this to make your app logic more robust and easier to maintain.
3. Type Predicates & Assertion Functions: Customize TypeScript's control flow and improve code inference to make your codebase more manageable.
4. Classical Patterns (Builder, Composite, Iterator, etc): Build on your knowledge of Generics to perform awe-inspiring feats of inference, developing entire data structures without manual type annotation.
5. External Libraries: Get down and dirty with external libraries, understanding how generics flow through them to debug type errors quickly.
6. Thinking on the Compiler Level: Understand the critical role of various TypeScript compiler internals, to understand the result and results, which are not explicitly written in your code.
What You'll Learn:
- Deepen your understanding of TypeScript's advanced features
- Navigate and resolve complex compiler errors
- Gain techniques for efficient domain modeling
- Master type controls to write cleaner and more reliable code
By the end of this hands-on workshop, you’ll be armed with a toolkit of advanced TypeScript skills and techniques, ready to tackle any coding challenge. Don't miss out on this opportunity to turbocharge your TypeScript game! 💪🤓
In this foundational workshop, you'll gain a clear understanding of modern software architecture principles tailored for the age of AI-assisted development. Whether you're building new applications or evolving existing systems, architectural thinking is more important than ever in a world where AI is transforming how we write and maintain code.
We will cover the core principles of modular, scalable, and testable system design, and explore how AI tools—from copilots to code generators—impact architectural decisions. You'll learn how to design clean, evolvable codebases that embrace automation without losing control of structure, quality, or maintainability.
Through hands-on exercises and real-world case studies, you'll walk away with practical knowledge to apply in your daily work—whether you're building microservices, monoliths, or hybrid architectures powered by intelligent components.
What You'll Learn:
✔️ Core Architectural Patterns: Learn how to apply proven patterns like layered, hexagonal, and event-driven architectures in AI-supported workflows.
✔️ Designing for AI: Understand how AI assistants change the way we model, refactor, and document systems—and how to use them effectively.
✔️ Trade-offs and Boundaries: Make better decisions around coupling, cohesion, team ownership, and long-term evolution of codebases.
✔️ Architecture as Code: Discover tools and techniques for modeling and validating your architecture using modern developer workflows.
✔️ AI Integration Points: Explore where and how to integrate AI-powered services, models, and APIs within robust software architectures.
Who Should Attend:
Developers, tech leads, and architects who want to build strong architectural foundations while embracing AI-assisted tooling. No prior AI experience is required—just a passion for clean, thoughtful system design.
Future-proof your codebase and your career. Join us to master the fundamentals of software architecture for the AI-assisted era.
Sign up to receive updates about AI Poland, including workshops, speaker announcements, ticket releases, AI Awards, expert interviews, CFP details, and other exclusive content. We won't spam you — only thoughtfully curated updates we believe you'll find truly valuable. You can unsubscribe at any time. More information available here.