Tech Events & Workshops

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.

We've all seen it: you ask an AI for a simple feature, and it returns a 50-line wall of boilerplate filled with nested interfaces and redundant logic. As engineers, we still have to read, understand, and debug that code. The more "noise" in our stack, the more room there is for hallucinations, and the harder it is for us to spot them. This Saturday, we're exploring how to cut through that noise. We'll look at Clojure(Script), a language where code is data. By reducing the surface area of our syntax, we don't just save tokens; we gain a level of clarity that makes it easier for humans to reason about their systems and for AI to stay on track. *The "Honesty" Stack:* - **Malli as the Source of Truth:** Learn how shared schemas act as a "Contract of Honesty." Whether a human wrote the code or an LLM generated it, Malli ensures the data remains valid before it ever touches your logic. - **Hiccup & Replicant:** See how UI development changes when your DOM is just a data structure. We'll use Replicant to demonstrate how pure-data templates (Hiccup) lead to high-performance, predictable interfaces without the "magic" of complex frameworks. - **HoneySQL:** Why write strings when you can write maps? We'll show how database queries become searchable, composable data, keeping your persistence layer as clear as your business logic. - **The Living REPL:** Experience a tight feedback loop where you evaluate snippets instantly in a running environment. It's the ultimate tool for verifying behavior and ensuring that what you (or your AI) just wrote actually works. ## Why Attend? If you're looking for a way to build robust, verifiable systems without the weight of traditional boilerplate, this talk is for you. We aren't here to talk about AI doing your job - we're here to talk about how Clojure(Script) makes you a more effective architect of the code you produce.