The Polylith Mindset: Build Faster Across Multiple Projects

We can now generate code faster than ever, but that creates a new problem: teams can also generate confusion, duplication, and fragile architecture faster than ever.
In this session, we'll explore how to design software systems that help both humans and AI move faster safely. The focus is on clear module boundaries, reusable components, stable interfaces, validation contracts, and Polylith-inspired thinking from the Clojure ecosystem.

## What We'll Cover

• Modular Architecture for AI-Assisted Development: Structure large systems so features have clear ownership and predictable boundaries.
• Interfaces as Guardrails: Use narrow interfaces to make code easier to replace, test, and reason about.
• Contracts & Validation: Treat validation rules and schemas as a shared source of truth between humans, tools, and AI agents.
• Multi-Project Reuse: Learn how shared components can support multiple products without turning into a tangled framework.
• Metaprogramming & Automation: Use macros, code generation, and declarative patterns to reduce repetitive implementation work.

## Why Attend?

If you're using AI to build software, the real question is no longer "Can it write code?" The question is: can your architecture absorb that speed without collapsing under complexity?
This talk is for developers who want to build larger systems faster while keeping the codebase understandable, testable, and adaptable.

--------

Nous pouvons désormais générer du code plus rapidement que jamais, mais cela crée un nouveau problème : les équipes peuvent également générer de la confusion, de la duplication et une architecture fragile plus rapidement que jamais.
Dans cette session, nous explorerons comment concevoir des systèmes logiciels qui aident à la fois les humains et l'IA à avancer plus vite en toute sécurité. L'accent sera mis sur des limites de modules claires, des composants réutilisables, des interfaces stables, des contrats de validation et une approche inspirée de Polylith issue de l'écosystème Clojure.

## Ce que nous allons couvrir

• Architecture modulaire pour le développement assisté par l'IA : Structurez les grands systèmes de manière à ce que les fonctionnalités aient une propriété claire et des limites prévisibles.
• Les interfaces comme garde-fous : Utilisez des interfaces étroites pour faciliter le remplacement, le test et la compréhension du code.
• Contrats et validation : Traitez les règles de validation et les schémas comme une source de vérité partagée entre les humains, les outils et les agents d'IA.
• Réutilisation multi-projets : Apprenez comment les composants partagés peuvent prendre en charge plusieurs produits sans se transformer en un cadre enchevêtré.
• Métaprogrammation et automatisation : Utilisez des macros, la génération de code et des modèles déclaratifs pour réduire le travail d'implémentation répétitif.

## Pourquoi y assister ?

Si vous utilisez l'IA pour créer des logiciels, la vraie question n'est plus « Peut-elle écrire du code ? » La question est : votre architecture peut-elle absorber cette vitesse sans s'effondrer sous la complexité ?
Cette conférence s'adresse aux développeurs qui souhaitent créer des systèmes plus grands plus rapidement tout en gardant la base de code compréhensible, testable et adaptable.