ElixirConf US 2026: What We Brought Home from Chicago

Intro

Earlier this September, the Mimiquate team traveled to Chicago for another edition of ElixirConf US.

As we've experienced over the years, one of the things that makes ElixirConf especially valuable is the chance to bring the community together in person. Elixir is still a relatively small ecosystem, which makes having a space to meet the people behind the language, exchange experiences, discover what others are building, and discuss where the ecosystem is heading particularly meaningful.

Something new this year were the roundtable discussions: moderated conversations around a specific topic. The topics were really interesting (Building High-Performing Engineering Teams, Being a Junior Dev in an Agentic World, and How Should We Be Programming in the Age of AI, to name a few), but they ran in parallel with the two tracks of talks. That meant fewer attendees per talk, which is a bit of a shame considering how much time goes into preparing one.

After a few days of talks, conversations, and new ideas, we came back with plenty to think about. Here are some of the talks that caught our attention and the main takeaways we brought home from ElixirConf US 2026.

Keynote Highlights

Set-Theoretic Types from Scratch: as has become tradition over the last three years, José talked about the type implementation in Elixir. This time, though, he implemented the type system from scratch, live, which was pretty cool. It was great to understand the work from such a practical angle. The whole type system can be implemented with just three main operations, which is kind of crazy. José did a great job explaining how to type more complex structures and how the complexity of the type system grows, even though, in the end, the whole implementation still relies on those same three operations. Investing in a type system looks like a choice that compounds for the ecosystem over time: with the advent of AI agents, building more automatic correctness checks into the language looks like a solid bet. This is also tangentially related to the rediscovery of formal methods, now that a lot of that effort can be tackled with agents.

The Graveyard of Good Ideas: Quinn Wilton's talks usually make me think deeply, and this one was no exception. In a rather unconventional talk, Quinn showed how AI can open up a whole new world of possibilities by letting builders hand off the parts they don't want to build to agents, so they can stay focused on the meat of the ideas they actually want to pursue. Basically, using AI to empower creativity by removing the most mechanical and boring parts of big ideas. She masterfully made this point while doing a deep dive into the history of climate prediction. I 100% recommend watching it.

What Comes Next: Chris McCord's keynote followed the thread he has been pulling on lately: pushing AI agents as far as they can go. Now that agents can run continuously, he showed how they have allowed him to take on ambitious projects that would have been hard to justify otherwise. Two examples he walked through are group, an eventually consistent distributed process registry with process groups and lifecycle monitoring, and durable_server, which gives you GenServers that persist their state and survive node failures and deployments. Both were built to power Sprites at Fly.io, and both are the kind of infrastructure work that used to take a team, not a single person with agents at their disposal.

Exoskeletons, not Autopilots: in his keynote, Zach Daniel presented what he believes is the future of software development (at least for now). He sees AI as an exoskeleton rather than an autopilot, making the distinction that AI should empower humans, not replace them. Beyond making the argument, he showed what this exoskeleton looks like in practice, walking through different ways you can empower your development teams: from simple recipes like automated code reviews, to more complex things like building a "homebase" app that holds all the context a bot needs to help with team productivity, checking project status, or facilitating communication between teams working on the same part of the app. This one really hit home for me in terms of where to stand on AI use, and how to make the most of it professionally.

Talks that caught my attention

Let It Crash (But Not Everything). Strategic Supervision for Resilient Systems: Joe Harrow and Stephanie Lane gave an extensive introduction to supervision strategies using a live band as the running example, which was both hilarious and useful.

Calculating the Sky in Pure Elixir: Jacob Johnson presented and demoed an astronomy tool he built himself, written in Elixir, to explore data published by NASA. I thought it was really cool to see Elixir being used somewhere I wouldn't have expected at all.

Learnings from Building a Global Cluster at Supabase: probably my favorite from a technical point of view. Filipe Cabaço walked through the performance bottlenecks Supabase ran into while scaling their real-time service. The most interesting part is that the solution to all of their problems could be found within the ecosystem itself, and he gave examples of how he and his team are using the tools that are already out there, such as syn, among others. If you're working on highly scalable systems, this one is a must.

Dexter: An Elixir LSP Optimized for Large Codebases: Jesse Herrick told the story of the different eras of language servers at Remote, and how he ended up creating a language server himself that could handle a codebase as big as Remote's, which is potentially the largest Elixir codebase in the world. Besides the story, which is interesting on its own, he showcased Dexter's most important features. The talk was good enough to convince me to try Dexter in my dev environment. So far, no complaints!

Let Your Code Tell Its Story: Runtime Comprehension in Elixir: I expected this to be more of an experience-sharing talk, but I was pleasantly surprised to find out it was about a tool for getting better insight into systems at runtime. CodeStory is a dev tool that traces a span of execution and renders a nested call tree of your app's functions, with named arguments, values, and return values, so you can easily understand what's going on. I can see it being really useful when getting onboarded onto a new app!

Phoenix Contexts in the Real World

I also presented this year, for the second time. My talk is available as a blog article here: Phoenix Contexts in the Real World.

The talk tackles the ongoing controversy around Phoenix contexts. They are often criticized for forcing Domain-Driven Design overhead onto small projects, but I argue the real problem isn't contexts themselves: it's the pressure to design domain boundaries upfront, precisely when you know the least about your domain. Instead, I propose starting with a single, deliberately coarse "god context" and letting real boundaries emerge through observation. The mental model is contexts as countries: boundaries should follow the natural divisions of the domain, and all traffic between contexts goes through a public "embassy" module that keeps each one sovereign over its schemas and behavior.

The practical part is a watchlist of signals that tell you when it's time to split a context (naming drift, the "and" test, border smuggling, test setup drag, and PR heatmaps) or to merge one, plus a step-by-step playbook for splitting safely in small, independent steps. The core idea is that structure amplifies whatever is already there: the same gravity that organizes code when you're paying attention turns into accretion when you're not.

Hallway track

A lot of the hallway track discussions I was part of were related to AI in some way. Some of them were very practical: which harness people were using, whether they were using agent swarms to get tasks done or something closer to pair programming. A lot of the technical discussions this year felt centered on how to verify software: how to do code review, whether to add more automated checks, or whether to lean on AI for this as well, using techniques like adversarial code review with multiple agents.

Other conversations were more existential: what the industry will look like in ten years, whether technical knowledge will still be relevant for doing development, or whether it will still make sense to pick a programming language to learn and become proficient at. I found that one particularly ironic given we were discussing it at a tech-specific conference, but we are living through a paradigm shift in the industry (if you're into philosophy, check out Kuhn's theory of paradigms), so I expect this kind of thing to keep happening.

Unconference

Another highlight of my trip was attending the Unconference organized by Dan Janowski, Director of Operations at the Erlang Ecosystem Foundation (EEF). We have been collaborating with the EEF for more than a year now, mostly helping out on the marketing side. Dan has been organizing these events as a lead-in to most of the conferences in the ecosystem. The format is very simple, and it basically lets attendees discuss whatever they feel matters most at the moment. Given the current state of affairs, it was impossible to avoid talking about AI, but we also covered other important, tangential topics: how to build community, what the future looks like for junior developers joining the ecosystem, and more. If you haven't attended one before, you should check it out.

Looking ahead

If there was one theme running through this year's ElixirConf, it was AI. Not as a novelty anymore, but as something everyone is trying to figure out how to use well. The framing that stuck with me is Zach's: agents as an exoskeleton, not an autopilot. Hand off the mechanical parts, keep humans on the ideas and on verifying the results. It's also why José's bet on types feels right: the more code gets written by agents, the more valuable automatic correctness checks become.

It also answered, at least for me, the hallway question of whether picking a language still matters. Between Supabase scaling a global cluster with tools that already exist in the ecosystem and Dexter handling one of the largest Elixir codebases in the world, the answer is that the runtime and the community still give you a lot that no agent can.

We're heading home with a few things to dig into. First, I want to go deeper into how to use AI to empower team workflows, along the lines of what Zach presented: not just individual productivity, but tooling that helps the whole team stay in sync. Second, I want to take a closer look at formal verification. I took a course on it back in college and never thought I would actually need it professionally, but now that agents can take on most of the heavy lifting, it suddenly looks a lot more practical. And of course, we'll keep working with the EEF.

If you were at the conference and want to compare notes, or if you want to talk about Phoenix contexts, reach out. And if you've never been to ElixirConf, I hope to see you at the next one.