Elixir Observer

Tower

Blend

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.

 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.

 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.

 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 

, an eventually consistent distributed process registry with process groups and lifecycle monitoring, and 

, 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.

 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.

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.

 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 

, 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!

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

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.

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 

), so I expect this kind of thing to keep happening.

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.

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.

ElixirConf US 2026: What We Brought Home from Chicago

Last month we had the chance to participate once again in 

, the largest Elixir conference in the United States. This year was especially exciting for us at Mimiquate because two of our team members presented talks: myself and 

. Beyond the presentations, we also showcased some of the progress we’ve made with our open source projects and shared our vision for making Elixir even more approachable to newcomers.

My Talk: Accelerating Elixir Adoption with Elixir Observer

 and how we can lower the barriers for developers who are new to the ecosystem. My talk centered on 

, a tool we built to help developers explore Elixir packages more easily.

Instead of jumping between Hex and GitHub to evaluate whether a package is mature or widely adopted, Observer consolidates all relevant information into a single place. But what makes it stand out is the emphasis on 

, which allows developers to process information faster and make more informed decisions.

ElixirConf 2025 – Introducing Elixir Observer

, but since then we’ve added several new features:

 Observer now checks each package’s repository for commits that haven’t been released yet. This helps developers anticipate activity levels and spot upcoming improvements. Each package page now shows how many commits are pending release, with a link to explore them directly.

 To improve discoverability, we introduced a fixed set of categories. Packages are classified automatically using Google’s Gemini based on their name and description. This makes browsing much more intuitive for newcomers.

 Until recently, Observer supported only rigid keyword-based search. With semantic search, developers can now search by concepts, making it easier to find packages even if they don’t know the exact keywords.

Together, these improvements make Elixir Observer a more powerful entry point for anyone exploring the Elixir ecosystem.

Gonzalo’s Talk: Building an Exception Tracker in Elixir

Gonzalo’s talk focused on exception tracking in Elixir. His presentation walked the audience through the journey of handling errors while building products, and how that experience led us to create 

Tower is a flexible package for exception handling and reporting. It allows developers to integrate with any exception tracking provider, making it easier to centralize error visibility across systems.

👉 You can watch Gonzalo’s talk here: 

ElixirConf 2025 – Building an Exception Tracker

Looking ahead, we’re working on introducing Igniter support across the entire Tower ecosystem. This will simplify installation and configuration for developers. While doing this, we also discovered improvements that can be upstreamed into Igniter itself, and we’re excited to contribute back to the tool in the near future.

ElixirConf US is always a special time for us: a chance to connect with the Elixir community in the United States, share what we’ve been building, and learn from others pushing the ecosystem forward. This year felt particularly rewarding as we showcased both 

our commitment to adoption (Elixir Observer)

At Mimiquate, we believe that by sharing our learnings and building open source tools, we can help the Elixir ecosystem grow stronger, more approachable, and better equipped for the challenges ahead.

✦ If you haven’t yet, check out the talks above and give our open source projects a try. We’d love to hear your feedback!

Community & Open-Source

Cutting-edge
initiatives

Leadership at Mimiquate

Open-Source

Elixir Observer

Tower

Blend

Looking ahead

Community events

ElixirConf US 2026: What We Brought Home from Chicago

Mimiquate at ElixirConf 2025 & open source updates

Host an event
with us!

Dependable, professional & cost-effective services

Community & Open-Source

Cutting-edge initiatives

Leadership at Mimiquate

Event Sponsorship

Collaborative Community

Open-Source

Elixir Observer

Tower

Blend

Looking ahead

Community events

ElixirConf US 2026: What We Brought Home from Chicago

Mimiquate at ElixirConf 2025 & open source updates

Host an event with us!

Dependable, professional & cost-effective services

Cutting-edge
initiatives

Host an event
with us!