In the final episode of Season 15, Charles Suggs and Emma Whamond are joined by James Gray, co-author of Designing Elixir Systems with OTP, to talk about what has changed in software development and what still holds true. Years after the book’s release, many of its core ideas around architecture, boundaries, supervision, and system design remain deeply relevant, even as AI tools reshape how developers learn, build, and collaborate.

James brings a unique perspective to the conversation: he is an experienced Elixir and OTP educator who only recently began using LLMs in his own workflow. He shares what surprised him, where the tools have been useful, where they have created risk, and what happened when Claude accidentally wiped his local development database. The conversation explores how AI can speed up parts of the work while making foundational knowledge, code review, testing, and clear system boundaries even more important.

To close the season, James and the hosts reflect on what developers should hold onto as the stack continues to shift. They discuss responsible LLM usage, the changing role of pair programming, who owns the mental model when AI helps write code, and why Elixir’s long-standing strengths may matter even more in an AI-assisted development world.

James is scheduled to speak at ElixirConf 2026, September 10–11 in Chicago, and the Elixir Wizards will be there too! Join us and the broader Elixir community, and use promo code Elixirwizards for 10% off in-person or virtual tickets at https://elixirconf.com/

Key topics discussed in this episode:

• James Gray’s work on Designing Elixir Systems with OTP
• What still holds true in Elixir system design
• Layered architecture and durable software fundamentals
• Functional core, imperative shell in modern applications
• Supervision trees as application lifecycle maps
• Why boundaries still matter in AI-assisted development
• What AI changes about learning and building software
• What AI does not change about software design
• James’ first month using LLMs
• When Claude erased a local development database
• Trust, verification, and responsible LLM usage
• The risk of AI-generated boundary violations
• Pair programming, mental models, and developer judgment
• Ethical and legal questions around AI tools
• Why OTP concepts still matter in distributed systems
• How Elixir thinking applies to AI agent workflows
• What developers should preserve as the stack shifts
• James’ upcoming ElixirConf talk

Links mentioned:

Java Programming Language https://www.java.com/en/
Perl Programming Language https://www.perl.org/
Ruby Programming Language https://www.ruby-lang.org/en/
Best of Ruby Quiz by James Gray https://www.google.com/books/edition/Best_of_Ruby_Quiz/bMggAQAAIAAJ
Designing Elixir Systems with OTP https://pragprog.com/titles/jgotp/designing-elixir-systems-with-otp/
RubyConf talk: Boundaries by Gary Bernhardt https://youtu.be/yTkzNHF6rMs
Book: Real-World Event Sourcing by Kevin Hoffman https://pragprog.com/titles/khpes/real-world-event-sourcing/
Broadway Library https://elixir-broadway.org/
Supervision Trees https://elixir.hexdocs.pm/supervisor-and-application.html
PostgreSQL https://www.postgresql.org/
ClickHouse https://clickhouse.com/
GenServer https://elixir.hexdocs.pm/GenServer.html
Programming as Theory Building by Peter Naur https://pages.cs.wisc.edu/~remzi/Naur.pdf
“A computer can never be held accountable, therefore a computer must never make a management decision.” – IBM Training Manual, 1979
Oban https://oban.pro/
Anthropic Claude Fable https://www.anthropic.com/claude/fable
Claude Design https://claude.com/product/design
Tidewave Agentic Dev Environment for Phoenix and Rails https://tidewave.ai/
2x – nine months later: We did it https://ideas.fin.ai/p/2x-nine-months-later
James Gray’s Blog https://programmersstone.blog/about/
ElixirConf https://elixirconf.com/
ExMex https://exmexconf.com/

Special Guest: James Gray.

In this episode of Elixir Wizards, Charles Suggs and Emma Whamond are joined by Zach Daniel, creator of the Ash Framework and Igniter, VP of Engineering at Remedy Meds, and upcoming ElixirConf keynote speaker, to talk about what sits between an LLM and useful engineering work.

Zach reflects on how much has changed since his last appearance on the podcast in October 2024, moving from Igniter, code generation, and project patching into AI agents, context layers, and custom engineering workflows. The conversation explores how deterministic tools and probabilistic LLMs can work together, and why the most useful AI systems often depend on the structure built around the model.

We also discuss why teams should be careful about outsourcing the systems that hold their organizational knowledge and decision-making. He shares his perspective on owning the AI stack, building internal knowledge systems, training junior developers in an AI-augmented world, avoiding vendor lock-in, and why Elixir may be especially well-suited for safer agentic workflows.

Zach will be a keynote speaker at ElixirConf 2026, September 10–11 in Chicago, and the Elixir Wizards will be there too! Join us and the broader Elixir community, and use promo code Elixirwizards for 10% off in-person or virtual tickets at https://elixirconf.com/

Key topics discussed in this episode:

• Zach Daniel’s work with Ash, Igniter, and AI tooling
• How software development has changed since 2024
• Deterministic code generation vs. LLM-generated code
• Combining structured tools with AI agents
• What it means to own your AI stack
• Organizational knowledge as an engineering “spinal column”
• Context layers, documentation, and internal workflows
• Building custom agentic systems
• Security, vendor lock-in, and open source LLMs
• Junior developers and apprenticeship in the AI era
• Why Elixir and the BEAM fit agentic workflows

Links mentioned:

Ash Framework https://ash-hq.org/
Igniter https://igniter.hexdocs.pm/
Phoenix Framework https://www.phoenixframework.org/
Remedy Meds https://remedymeds.com/
Keynote: Code Generators are Dead. Long Live Code Generators - Chris McCord | ElixirConf EU 2025 https://www.youtube.com/watch?v=ojL_VHc4gLk
https://phoenix.hexdocs.pm/Mix.Tasks.Phx.Gen.Live.html
LSP https://en.wikipedia.org/wiki/Language_Server_Protocol
Claude Code https://claude.com/product/claude-code
GitHub Actions https://github.com/features/actions
Harness Engineering https://en.wikipedia.org/wiki/Agent_harness
Claude SDK https://code.claude.com/docs/en/agent-sdk/overview
Zach's Twitter https://x.com/ZachSDaniel1
ElixirConf https://elixirconf.com/
AshConf https://luma.com/wz4z0iz6
Goatmire https://goatmire.com/

Special Guest: Zach Daniel.

In this episode of Elixir Wizards, Charles Suggs and Emma Whamond are joined by Flora Petterson, a self-taught Elixir developer, speaker, and maker, to talk about what happens when software systems forget and how developers can design for recovery.
 
Flora shares her unconventional path to programming, from puppetry and creative work to discovering Elixir through Nerves and hardware projects. The conversation centers on her talk, “After the Crash,” which uses forgetting as a way to think about failure in software systems. Flora and the hosts explore process crashes, lost state, GenServer lifecycle, supervision, “let it crash,” and the difference between preventing failure and building systems that know how to recover.
 
The episode also expands from software memory to team memory. Flora discusses documentation, institutional knowledge, mentorship, storytelling, and the challenge of preserving both what a system does and why decisions were made. Along the way, she shares how creative, low-stakes projects can help developers build deeper technical understanding and how the Elixir community can continue supporting new and self-taught engineers.

Key topics discussed in this episode:

• Learning through experimentation with Nerves, hardware, and animatronics
• What it means for software systems to “forget”
• Failure, recovery, and lost state in the BEAM
• GenServer lifecycle and process recovery
• The nuance behind “let it crash”
• What supervision trees can and cannot protect
• Designing systems to recover from failure
• Deciding when state should be recovered or abandoned
• Documentation as organizational memory
• Capturing the “why” behind technical decisions
• Tests, docs, and examples as living knowledge
• Mentorship for self-taught and junior developers
• Storytelling as technical communication
• Creative projects as a path to deeper learning
• AI’s impact on new developers
• Community, curiosity, and growth in Elixir
• Join us and the broader Elixir community at ElixirConf in Chicago this September 10-11. Use promo code Elixirwizards for 10% off in-person or virtual tickets at https://elixirconf.com/

Links mentioned:

Embedded Elixir Nerve https://nerves-project.org/
Gig City Elixir Conference https://www.gigcityelixir.com/
Strange Loop Conference https://www.thestrangeloop.com/
Elixir Wizards S15E05 The State of Code Quality with Saša Jurić http://bit.ly/EWS15E05
One Art by Elizabeth Bishop https://www.poetryfoundation.org/poems/47536/one-art
"Systems that run forever self-heal and scale" by Joe Armstrong (2013) https://www.youtube.com/watch?v=cNICGEwmXLU
Conway's Law https://en.wikipedia.org/wiki/Conway%27s_law
Dunning–Kruger effect https://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect
Elixir Wizards S15E10 Bruce Tate http://bit.ly/EWS15E10
Designing Elixir Systems with OTP by James Gray & Bruce Tate https://pragprog.com/titles/jgotp/designing-elixir-systems-with-otp/
GenServer Behavior https://elixir.hexdocs.pm/main/GenServer.html
IEx https://iex.hexdocs.pm/IEx.html
Domain Driven Design by Eric Evans https://www.domainlanguage.com/
GDPR General Data Protection Regulation https://gdpr-info.eu/
https://blog.cleancoder.com/uncle-bob/2017/02/23/NecessaryComments.html
Living Documentation by Cyrille Matraire https://www.oreilly.com/library/view/living-documentation-continuous/9780134689418/
Exciting ExDoc talk by Flora Petterson 2025 CodeSync https://www.youtube.com/watch?v=tLr9FOARwzQ
ExDoc https://ex-doc.hexdocs.pm/
The AI Coding Crisis Blog Series https://grox.io/blog/series/the-ai-coding-crisis/
Build Animatronics with Nerves talk https://www.youtube.com/watch?v=4Ulurej4NTg
Sam Aaron Sonic Pi https://sonic-pi.net/
https://scratch.mit.edu/
https://www.scratchfoundation.org/learn
Nerves LiveBook https://github.com/nerves-livebook/
Hardware for Embedded Systems https://www.raspberrypi.com/
Goatmire Conference https://goatmire.com/

In this episode, Elixir Wizards Charles Suggs and Emma Whamond are joined by Bruce Tate, founder of Groxio and longtime Elixir educator, to discuss career growth and mentorship in the age of AI.

Bruce reflects on Elixir’s evolution and explores how AI coding agents are changing the way developers learn, work, and advance. He explains his “anti-vibe coding” philosophy and recommends practices for maintaining code quality, arguing that many struggles attributed to junior developers are really failures of training and mentorship.

Rather than using AI productivity gains to eliminate entry-level roles, Bruce challenges teams to reinvest that time in educating juniors to support their long-term career path.

Bruce will expand on this conversation at ElixirConf 2026, September 10–11 in Chicago, and the Elixir Wizards will be there too! Join us and the broader Elixir community, and use promo code Elixirwizards for 10% off in-person or virtual tickets at https://elixirconf.com/

Topics discussed in this episode:

• The evolution of the Elixir ecosystem from conception to now
• Rethinking career growth and mentorship in the age of AI
• What “anti-vibe coding” means
• Functional core and imperative shell design
• OTP fundamentals and architectural literacy
• Managing AI-generated code and pull requests
• Mentorship beyond code review
• Developing engineering judgment
• API design as a core skill
• AI as a force multiplier for junior developers
• Reinvesting AI productivity gains in people

Links mentioned:

https://grox.io/
Seven Languages in Seven Weeks by Bruce Tate https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/
Programming Phoenix LiveView https://pragprog.com/titles/liveview/programming-phoenix-liveview/
BASIC Programming Language https://www.purebasic.com/
C++ Programming Language https://cplusplus.com/
COBOL Programming Language https://www.ibm.com/think/topics/cobol
Fortran Programming Language https://fortran-lang.org/
Bitter Java by Bruce Tate https://www.amazon.com/Bitter-Java-Bruce-Tate/dp/193011043X
Slashdot Effect https://en.wikipedia.org/wiki/Slashdot_effect
Slashdot https://slashdot.org/
Java Programming Language https://www.java.com/en/
Ruby Programming Language https://www.ruby-lang.org/en/
Lisp Programming Language https://lisp-lang.org/
Haskell Programming Language https://www.haskell.org/
Erlang Programming Language https://www.erlang.org/
Eric Meadows-Jönsson https://github.com/ericmj
Machine Learning in Elixir by Sean Moriarity https://pragprog.com/titles/smelixir/machine-learning-in-elixir/
The AI Collective https://www.aicollective.com/
Elixir Pipe Operator https://operator.hexdocs.pm/readme.html
Phoenix Framework https://www.phoenixframework.org/
Phoenix LiveView https://phoenix-live-view.hexdocs.pm/Phoenix.LiveView.html
Broadway https://hex.pm/packages/broadway
Designing Elixir Systems with OTP by James Edward Gray & Bruce Tate https://pragprog.com/titles/jgotp/designing-elixir-systems-with-otp/
The AI Coding Crisis Blog Series https://grox.io/blog/series/the-ai-coding-crisis/
Groxio Live https://grox.io/live

Special Guest: Bruce Tate.

In this episode of Elixir Wizards, Charles Suggs and Emma Whamond are joined by Mallory Knodel, executive director and founder of the Social Web Foundation, to talk about internet governance, open standards, and the future of the social web. Mallory shares how her work as an activist, systems administrator, and public interest technologist led her into the organizations and working groups that shape how the internet functions, including the IETF, W3C, ICANN, and ITU.

The conversation explores how the internet shifted from a collection of open protocols toward a small number of dominant platforms, and what that centralization means for users, developers, and independent service providers. Mallory explains how decisions made at the protocol level can affect everything from email deliverability to identity, data portability, trust and safety, and the ability to move between platforms. We also discuss the Social Web Foundation, ActivityPub, the Fediverse, and the idea of building a more multipolar social web.

Mallory also looks at what happens when AI agents, automated accounts, and algorithmic feeds enter open social ecosystems. She shares her perspective on privacy, usability, encrypted messaging, and designing technology around user needs rather than engagement alone.

Key Topics Discussed

• What it means to be a public interest technologist
• How internet governance affects everyday software development
• The role of global internet standards organizations
• How the IETF and W3C develop technical standards
• Corporate influence inside internet governance and standards bodies
• The internet’s shift from protocols to centralized platforms
• Email deliverability and the hidden costs of centralization
• How platform control affects identity and user autonomy
• Why data portability remains difficult across social platforms
• The mission behind the Social Web Foundation
• How the Fediverse connects independent social platforms
• ActivityPub and Activity Streams as open web protocols
• AT Protocol, an alternative to ActivityPub
• How federated servers exchange content and user activity
• Why a multipolar web differs from decentralization
• What Meta’s ActivityPub adoption means for federation
• The embrace, extend, extinguish risk for open protocols
• Discoverability challenges across federated social networks
• Trust and safety for smaller platform operators
• How protocol decisions can affect human rights
• AI agents entering open social web ecosystems
• Whether federated platforms should block automated crawlers
• Designing algorithmic feeds around values and user choice
• Privacy-first principles for developers building social software
• Encrypted direct messaging for the open social web
• Elixir projects building across the Fediverse ecosystem

Links Mentioned:

Mallory’s Website https://malloryknodel.net/
Internet Protocol (IP) https://en.wikipedia.org/wiki/Internet_Protocol
Internet Engineering Task Force (IETF) https://www.ietf.org/
International Communication Union https://www.itu.int/en/
Internet Corporation for Assigned Names and Numbers (ICANN) https://www.icann.org/
World Wide Web Consortium (W3C) https://www.w3.org/
Huawei https://www.huawei.com/en/
Cisco https://www.cisco.com/
Messaging, Malware and Mobile Anti-Abuse Working Group (M³AAWG) https://www.m3aawg.org/
Social Web Foundation https://socialwebfoundation.org/
ActivityPub https://www.w3.org/TR/activitypub/
AT Protocol https://atproto.com/
MeWe Decentralized Social Networking Protocol (DNSP) https://dsnp.org/about/MeWe-use-case.html
BlueSky https://bsky.app/
Mastodon https://joinmastodon.org/
Internet Society https://www.internetsociety.org/
Fediverse https://fediverse.party/
NCSA Mosaic Browser https://www.ncsa.illinois.edu/research/project-highlights/ncsa-mosaic/
Webring https://en.wikipedia.org/wiki/Webring
https://tags.pub/

Elixir projects:

• Pleroma https://pleroma.social/
• Akkoma https://akkoma.social/
• Bonfire Networks https://bonfirenetworks.org/
• Mobilizon https://mobilizon.org/

In this episode of Elixir Wizards, Charles Suggs and Emma Whamond are joined by Mike Ratliff, co-founder and CTO of GridVar, to talk about the role software plays in the changing energy infrastructure. With over 30 years of experience in technology, Mike shares the path that took him from the early internet and cloud computing into energy and utility software, along with what he has learned about staying adaptable as the industry continues to shift.

Mike explains why building software for the power grid comes with a very different set of constraints than building a typical web application and breaks down some of the challenges utilities are facing, including grid interconnection delays, power quality, increasing energy demand, and the growth of distributed energy resources. We also discuss demand response, microgrids, virtual power plants, battery storage, and how software can help utilities better understand and manage a grid that is becoming more complex.

Mike also explains why Elixir and the BEAM are a strong fit for always-on energy systems, how an Erlang MQTT server first led him into the ecosystem, and what it takes to introduce Elixir inside an established organization. The episode closes with a broader look at AI-assisted development, the value of domain expertise, and why technical leaders still need communication, judgment, and a compelling story to move important ideas forward.

Key topics discussed in this episode:

• Mike Ratliff’s path from software to energy technology
• Lessons from three decades of technology industry change
• The value of generalists in modern software engineering
• Why good technical judgment remains difficult to replace
• Building software that interacts with physical infrastructure
• Why utility technology adoption can move slowly
• Understanding today’s grid interconnection backlog
• Power quality challenges affecting new grid connections
• Using simulation to accelerate utility engineering studies
• Centralized and distributed approaches to grid management
• How solar energy creates the duck curve
• Using demand response to balance electricity consumption
• Edge devices supporting real-time grid coordination
• Microgrids and resilience in distributed energy systems
• Cybersecurity considerations for increasingly connected power grids
• Preparing utility infrastructure for extreme weather events
• Battery storage and the growth of renewable energy
• How virtual power plants coordinate distributed resources
• Why Elixir works well for energy software
• BEAM reliability for always-on utility infrastructure
• Discovering Elixir through Erlang and MQTT
• Building an early virtual power plant with Elixir
• Making the business case for an Elixir migration
• Why technical leadership also requires effective storytelling

Links Mentioned:

GridVAR https://www.gridvar.com/
GridPoint https://www.gridpoint.com/
https://en.wikipedia.org/wiki/2025_Iberian_Peninsula_blackout
Demand Response: https://en.wikipedia.org/wiki/Demand_response
Virtual Power Plant: https://en.wikipedia.org/wiki/Virtual_power_plant
Microgrid: https://en.wikipedia.org/wiki/Microgrid
Volts podcast: https://www.volts.wtf/

In this episode of Elixir Wizards, Charles Suggs and Emma Whamond are joined by Ellyse Cedeno, founder of Heuristic Salvo and a software engineer and product leader with more than 25 years of experience across early internet platforms, gaming, health tech, and distributed systems.
 
Ellyse shares the winding path that took her from early search engines and Netscape to game development, medical research at Mount Sinai, and eventually to Elixir. Along the way, she talks about staying curious over a long technical career, rediscovering joy through side projects, and why being willing to feel like a beginner again can be one of the most useful skills a developer can build.
 
The conversation explores what it means to grow as an engineer in a world where AI tooling is becoming part of the everyday workflow. Ellyse makes the case that technical skill still matters, but the human parts of software development (like judgment, curiosity, communication, trust, and influence) are becoming increasingly important.
 
We also talk about soft influence and how developers can create change inside organizations without relying on hard authority.

Key Topics Discussed in this Episode:

• Ellyse’s career path through early internet platforms, gaming, health tech, and distributed systems
• Moving from Netscape and search engines to medical research and software consulting
• Discovering Elixir through an interest in concurrent and distributed systems
• Why beginner’s mindset still matters after decades in tech
• How neurodivergence, curiosity, and deep focus shape Ellyse’s approach to programming
• Rediscovering joy in programming through side projects and experimentation
• Building an MMORPG game server in Elixir
• Exploring hardware, Nerves, and live theremin demos
• The role of passion projects in professional growth
• Protecting time for learning in productivity-focused environments
• Work-life balance differences between the U.S. and Europe
• How AI tools are changing expectations for modern developers
• Why AI does not replace judgment, taste, or technical understanding
• Understanding business needs instead of only focusing on technical preferences
• Introducing Elixir into a TypeScript-heavy organization
• Using Elixir microservices to solve specific technical problems
• What “soft influence” looks like in engineering teams
• Building trust through one-on-one conversations
• Knowing when influence is working and when it is not
• Negotiating technical decisions without turning them into power struggles
• The relationship between technical competence and interpersonal skill
• Managing imposter syndrome during pair programming and collaborative work
• Documentation as a visibility and ownership tool
• Community involvement, conference speaking, and finding your people
• Staying curious without burning out
• Why the human side of software development still matters

Links Mentioned:

https://en.wikipedia.org/wiki/Netscape
Icahn School of Medicine at Mt. Sinai https://icahn.mssm.edu/
Evernote https://evernote.com/
Joplin https://joplinapp.org/
Book: Elixir in Action by Saša Jurić https://www.manning.com/books/elixir-in-action-third-edition
Book: The Little LISPer https://www.scribd.com/doc/263131641/The-Little-Lisper
Ellyse’s Goatmire Talk https://goatmire.com/speaker/ellyse-cedeno
Nerves https://nerves-project.org/
xHain Hack & Makespace in Berlin https://x-hain.de/en/
https://cursor.com/
Haskell Programming Language https://www.haskell.org/
Java Programming Language https://www.java.com/en/
Clojure Programming Language https://clojure.org/
Scheme Programming Language https://www.scheme.org/
TypeScript Programming Language https://www.typescriptlang.org/
Nostrum Library https://hexdocs.pm/nostrum/intro.html
Gleam Programming Language https://gleam.run/
Book: Getting Past No by William Ury https://www.williamury.com/getting-past-no/
“The Gambler” by Kenny Rogers https://www.youtube.com/watch?v=7hx4gdlfamo
Ted Talk: Do schools kill creativity? | Sir Ken Robinson https://youtu.be/iG9CE55wbtY
Ellyse’s Codeberg https://codeberg.org/ellyxir
Ellyse’s Game Server Repo https://codeberg.org/ellyxir/gameserver
Goatmire Elixir & NervesConf 2026 https://www.goatmire.com/

In this episode of Elixir Wizards, hosts Charles Suggs and Emma Whamond sit down with Marek Šuppa, creator of the Missing GitHub Status page, a project that reconstructs GitHub's historical uptime data and reveals discrepancies between official status reporting and the platform's actual reliability.
 
Marek tells us about his dev journey from open source contributor at DuckDuckGo to machine learning engineer at Cisco-acquired Slido. Then, we discuss GitHub’s evolution from a hosted Git service into a critical developer tool. We cover reliability, transparency, AI-driven platform growth, developer workflows, and the challenges of balancing convenience with resilience.
 
Along the way, we cover alternative platforms, self-hosted solutions, and whether recent outages are changing how developers think about ownership, dependency, and the future of software collaboration.

Topics Discussed in this Episode:

• Why did Mr. Shu create the Missing GitHub Status Page?
• GitHub's reported uptime versus developer experiences
• How open source contributions shaped Marek's career
• The evolution of GitHub from tool to critical infrastructure
• Centralization risks in modern software development
• Git's distributed roots and today's platform-centric workflows
• Developer reactions to GitHub outages
• Transparency and accountability in status reporting
• AI's impact on developer platforms and infrastructure demands
• Microsoft's stewardship of GitHub
• Forgejo, Codeberg, and alternative Git hosting platforms
• Self-hosted Git solutions and tradeoffs
• Network effects and platform lock-in
• The social side of software collaboration
• Building resilience into developer workflows
• What GitHub outages teach us about infrastructure dependency

Links Mentioned:

The Missing GitHub Status Page https://mrshu.github.io/github-statuses/
Slido https://www.slido.com/
https://duckduckgo.com/
The official GitHub Status Page https://www.githubstatus.com/
Statuspage.iohttps://www.atlassian.com/software/statuspage
Zig Leaves GitHub https://ziglang.org/news/migrating-from-github-to-codeberg/
Ghostty Leaves GitHub https://mitchellh.com/writing/ghostty-leaving-github
GitLab https://about.gitlab.com/
Codeberg https://codeberg.org/
https://git.kernel.org/
Forgejo Lightweight Self-Hosting https://forgejo.org/
Former GitHub CEO Thomas Dohmke launches Entire https://entire.io/news/former-github-ceo-thomas-dohmke-raises-60-million-seed-round
Update on Spain and LALIGA blocks of the internet https://vercel.com/blog/update-on-spain-and-laliga-blocks-of-the-internet

In this episode of Elixir Wizards, hosts Charles Suggs and Emma Whamond sit down with Saša Jurić, Elixir mentor and author of Elixir in Action, to discuss software craftsmanship in the age of AI. As AI coding tools become increasingly capable, Saša argues that the real challenge isn't generating code, it's maintaining quality, clarity, and shared understanding within a codebase.
 
We explore the difference between correct code and good code, and why code is more than a set of instructions for a machine to execute. Code is also documentation, communication, and a long-term investment that future developers must be able to understand and maintain. Saša shares his concerns about the growing "theater of pull requests," where teams go through the motions of code review without creating meaningful opportunities for learning, feedback, or knowledge sharing.
 
The hosts and Saša talk about practical ways to work effectively with AI, including taking smaller steps, carefully reviewing AI-generated code, and using AI as a collaborative tool rather than an autonomous developer. Throughout the discussion, Saša challenges the industry's obsession with speed and makes the case that the principles of good software development (incremental progress, clear communication, and human judgment) remain important in the age of AI.
 

Key Topics Discussed

• The difference between correct code and good code
• Code as communication, documentation, and shared understanding
• The "theater of pull requests" and ineffective review practices
• How AI is changing software development workflows
• Using AI as a collaborator rather than a replacement
• Why smaller, incremental changes lead to better outcomes
• Human oversight in AI-assisted development
• Balancing development speed with maintainability
• Pull request size and review effectiveness
• Commit history as a tool for storytelling and context
• The risks of accumulating technical debt faster with AI
• Testing and validating AI-generated code
• Refactoring AI-generated solutions for clarity
• Applying agile principles to AI-assisted workflows
• The role of experience and judgment in software design
• Why software craftsmanship still matters in the age of AI

Links mentioned

Code Complete by Steve McConnell https://khmerbamboo.wordpress.com/wp-content/uploads/2014/09/code-complete-2nd-edition-v413hav.pdf
Harness AI for DevOps, Testing, and AppSec https://www.harness.io/
Claude Code https://claude.com/product/claude-code
Claude Code GitHub https://github.com/anthropics/claude-code
Pull Request for Oban https://github.com/oban-bg/oban/pull/331
SMPP https://en.wikipedia.org/wiki/Short_Message_Peer-to-Peer
OpenAI Codex https://chatgpt.com/codex/
Opus AI https://opus.ai/
Tidewave https://tidewave.ai/
Credo Static Code Analysis https://github.com/rrrene/credo
https://smartlogic.io/podcast/elixir-wizards/s11-e09-static-code-analyzer-elixir-credo-ruby-rubocop/
Link to Sasa’s X post https://x.com/sasajuric/status/2029522378196238503
Saša Jurić “Tell Me A Story” at Goatmire https://www.youtube.com/watch?v=GOrKfCs-mr0
https://meks.quest/blogs/the-theatre-of-pull-requests-and-code-review
Looks Good to Me: Constructive Code Reviews by Adrienne Braganza https://www.manning.com/books/looks-good-to-me
Towards Maintainable Elixir: Testing https://medium.com/very-big-things/towards-maintainable-elixir-testing-b32ac0604b99
TDD, Where Did It All Go Wrong (Ian Cooper) https://youtu.be/EZ05e7EMOLM

Special Guest: Saša Jurić.

In Elixir Wizards S15E04, Charles Suggs and Emma Whamond are joined by Somtochi Onyekwere, a software engineer at Fly.io and contributor to the Corrosion distributed database project, to talk about distributed systems, infrastructure resilience, and the growing fragility of centralized cloud platforms.
 
We discuss what recent outages across major providers reveal about modern infrastructure and why more teams are starting to rethink assumptions around reliability, failover, and system design. Somtochi explains how Fly.io approaches geographic distribution, eventual consistency, and replication across nodes, along with the trade-offs that come with building systems this way.
 
The conversation explores CRDTs (Conflict-free Replicated Data Types), consensus, split-brain prevention, and what actually happens when distributed systems fail in production. We also talk about testing strategies, rollback planning, property-based testing tools, and how teams can reduce blast radius when things inevitably go wrong.
 
Along the way, we discuss AI infrastructure, sandboxing AI agents, and how newer workloads may add pressure to already centralized systems. The episode closes with practical advice for developers who want to build more resilient applications without over-complicating their architecture.

Topics Discussed in this Episode:

• Corrosion and distributed database replication
• Centralized cloud fragility and recent outage patterns
• Distributed systems versus traditional cloud architectures
• Multi-region deployment strategies for Phoenix applications
• CRDTs and conflict resolution in distributed systems
• Eventual consistency versus strict consistency tradeoffs
• Consensus, leader election, and split-brain prevention
• Testing failover and recovery scenarios
• Property-based testing and Antithesis
• Rollback planning for database schema migrations
• Reducing blast radius through system isolation
• Health checks and blue-green deployment strategies
• Fly Proxy request routing and replay behavior
• Cross-region synchronization and replication challenges
• Single points of failure inside “redundant” systems
• Backup restoration testing and disaster recovery planning
• Network partitions and failure handling in production
• Infrastructure monitoring and operational visibility
• AI infrastructure workloads and operational strain
• Sandboxing and securing AI agents
• Sprites and AI workflows at Fly.io
• Latency improvements from geographic distribution
• Distributed systems tradeoffs in real-world environments
• Transitive dependency failures across cloud providers
• Practical resilience strategies for modern engineering teams

Links Mentioned:

https://fly.io
https://github.com/superfly/corrosion
https://docs.gitops.weaveworks.org/
FluxCD https://fluxcd.io/
Fly.io Stateful Sandbox Environments https://sprites.dev/
Cloudflare Workers AI Inference Platform https://www.cloudflare.com/products/workers-ai/
“An AI Agent Just Destroyed Our Production Data. It Confessed in Writing” Twitter post from PocketOS founder: https://x.com/lifeof_jer/status/2048103471019434248
Oct 2025 AWS Outage https://www.theguardian.com/technology/2025/oct/24/amazon-reveals-cause-of-aws-outage
Dec 2025 Cloudflare Outage https://www.theguardian.com/technology/2025/dec/05/another-cloudflare-outage-takes-down-websites-linkedin-zoom
July 2025 Crowdstrike Outage https://www.ibm.com/think/news/recent-crowdstrike-outage-what-you-should-know
March 2026 Stryker Cyber Attack https://www.stryker.com/us/en/about/news/2026/a-message-to-our-customers-03-2026.html
https://aws.amazon.com/
https://cloud.google.com/
https://azure.microsoft.com/en-us
https://fly.io/docs/elixir/
CRDTs!! https://smartlogic.io/podcast/elixir-wizards/s13-e03-local-first-liveview-svelte-pwa/
https://antithesis.com/docs/resources/property_based_testing/
https://hex.pm/packages/proper

In Season 15 episode 3, Charles Suggs sits down with Greg Medland, aka “The Elixir Fixer,” to talk about the current state of hiring and the software jobs market in 2026.
 
Greg shares what he’s seeing from both sides of the hiring process as an Elixir-focused recruiter, from shifting company expectations to the growing importance of specialization, communication skills, and real-world product thinking. We discuss how the market has changed since the 2021–2022 hiring boom, why things feel more uncertain today, and how developers are adapting to a slower, more competitive landscape.
 
The conversation also explores how AI is affecting hiring workflows, résumé quality, technical interviews, and even the rise of fraudulent candidates. Greg explains why human relationships and reputation still matter more than ever, especially in smaller ecosystems like Elixir where community connections carry real weight.
 
Along the way, we talk about what junior developers are up against, why senior engineers with domain expertise continue to stand out, and what developers can do to position themselves more effectively in today’s market. Greg shares practical advice for building a sustainable career, developing a clear professional identity, and navigating a rapidly changing industry.
 

Topics discussed in this episode:

• The current state of the Elixir job market
• Hiring trends and market shifts since 2021–2022
• How AI is changing hiring and recruiting workflows
• Fraudulent candidates and AI-generated résumés
• Domain expertise vs. generalist engineering skills
• Product thinking and customer-focused development
• What companies are looking for in 2026
• Junior developer challenges in the current market
• Why senior specialists remain in demand
• Networking and relationship-building in tech
• Open source contributions and visibility in the Elixir community
• Standing out in a crowded hiring environment
• Résumé quality and application strategies
• The role of personal branding for developers
• Remote work trends and geographic hiring patterns
• Technical interview expectations and evaluation changes
• Startup vs. enterprise hiring differences
• Human connection in an increasingly automated industry
• Career resilience and long-term positioning
• Building a sustainable software engineering career

Links mentioned:

Socially Responsible Recruitment https://sr2rec.com/
Greg’s LinkedIn https://www.linkedin.com/in/elixirfixer/
Greg's email address: [email protected]