Posts tagged with Elixir

Learn how feature branches, binary verification, and pull requests create safe boundaries for AI coding agents while keeping humans in control of architecture decisions.

Learn why Elixir displays some integer lists as charlists, how Unicode code points differ from UTF-8 bytes, and how to inspect the data underneath text.

Learn why AI-assisted projects need three sources of truth aligned: the codebase, the agent context, and the repository that preserves prompts, plans, and project guidance.

Learn how Elixir MapSets work, why they belong with key-value data, and when to use them instead of list membership checks.

Bruce Tate explains why agentic coding fails when model priors, codebase evidence, and correction channels break down—and why explicit systems are easier to verify.

Learn how to review AI-generated Elixir code by separating functional core from boundary code, reading public APIs first, and catching missed domain requirements.

Learn how Elixir converters complete the Construct, Reduce, Convert pattern by turning tetromino structs into point groups the canvas can draw.

Learn how Tidewave's project_eval lets Claude Code inspect, test, and demonstrate behavior inside your running Elixir application through a shared IEx-style workflow.

Use Elixir structs as containers for fixed domain state. Learn how a tetromino struct keeps name, location, rotation, and color together while reducers update one field at a time.

Install Tidewave in a Phoenix app and learn the two ways to wire Claude into your Elixir workflow through browser-based Tidewave or Claude Code MCP.

Structs are maps with rules: fixed fields, a hidden __struct__ key, and clearer boundaries around domain data. Learn when to choose a map and when to reach for a struct in Elixir.

Bruce Tate argues that AI changes how we should choose programming languages: not by GitHub stars, but by problem fit, operational characteristics, abstractions, and training data consistency.

Learn how Claude's context hierarchy, AutoCompact, and memory tradeoffs affect AI-assisted Elixir development, and why structured oversight starts with managing what enters context.

Maps are Elixir's random-access key-value structure. Learn when to choose maps over keyword lists, how map lookup and updates work, and why maps integrate with Enumerable and Collectible.

Why Elixir's functional core, process isolation, OTP recovery, and runtime metadata make it a strong language for AI-assisted development without losing architecture decisions.

Elixir has three module directives for consuming code: require, import, and alias. Learn what each one means, when to use it, and how each choice affects readability.

Learn how Bruce Tate manages Claude context windows with compacting, clearing, and priming while preserving layered Elixir architecture and one source of truth per layer.

Bruce Tate shows why pure functions and the CRC pattern (construct, reduce, convert) don't just help humans reason about code — they help Claude generate, verify, and stay correct with fewer tokens.

Elixir documentation is not a stale comment beside your code. Learn how module attributes, IEx help, ExDoc, and doctests keep explanations close to the behavior they describe.

AI can produce a convincing architecture plan, but production systems need structured review. Bruce Tate shows how an Elixir architect catches security and design mistakes before implementation begins.

Mix tasks are not separate from your Elixir application. They are ordinary modules that implement Mix.Task, giving you a clean boundary around reusable project tooling.

Learn how Elixir programs stay easier to test and change by separating pure logic, IO boundaries, and API coordination into distinct layers.

Learn how meta workflow generation turns prompts into reusable project commands, making AI development workflows durable, repeatable, and reviewable.

Learn how recursion works as a natural Elixir design pattern, why accumulators make list processing stack-safe, and how this mental model leads directly to Enum.reduce.

Learn when AI tooling should live globally versus in the project so shared workflows stay versioned, visible, and aligned with the codebase.

Learn why Elixir lists are linked structures, how `[head | tail]` reveals their shape, and why building left then reversing once leads to clearer, faster code.

Learn when to use rules, skills, sub-agents, and slash commands so your AI workflow scales with structured oversight instead of context-heavy repetition.

Learn how Elixir control flow works with expressions, truthy checks, and pattern matching so you can choose the right tool and avoid hidden runtime failures.

If you keep retyping the same AI instructions, you do not have a workflow. Learn a practical three-layer structure to keep coding agents consistent.

Learn when to use tuples, tagged tuples, and keyword lists in Elixir, and why designing return values as contracts leads to clearer, more maintainable code.

A fast Phoenix LiveView build can look impressive, but hidden structural debt appears when you inspect what AI generated under speed pressure.

Learn how Elixir scope boundaries reinforce immutability, prevent hidden state changes, and make code behavior predictable.

A 30‑minute Phoenix LiveView demo looks magical – until you see how the yes loop creates hidden scope and long‑term maintenance cost.

Pattern matching in Elixir is about selecting structure, not storing values. Learn destructuring, pinning, and how match failure guides control flow.

Learn the Ask → Plan → Agent workflow, a two-level safety net, and context discipline for checkpoint-based AI coding in Elixir.

In Elixir, data shape determines how code behaves and reads. Learn when to use atoms, tuples, lists, and maps to make your intent explicit.

Elixir selects a function head by pattern matching the shape of your arguments, which is why the language feels declarative before you touch OTP.

The model didn't forget your architecture—it just never lived anywhere durable. Learn how to anchor decisions in structure instead of prompts.

Variables aren't containers you mutate, they're names that point at values. Learn why this distinction matters more than immutability alone.

In Elixir, if statements aren't control flow—they're expressions that return values. Learn how this eliminates state management and changes how you read code.

The syntax is easy. The mental model is hard. Learn the one shift that makes Elixir stop feeling sideways and start feeling natural.

Stop comparing features and benchmarks. Learn to match AI agents to your workflow with a practical decide-vs-execute rule you can use today.

Why AI agents lose context, how the conveyor belt model explains it, and a practical habit Elixir developers can use immediately to get better results.

Explore the five modes of collaborating with AI coding agents in Elixir — and why 'vibing' creates fragile systems.

Learn to recognize when complexity is hindering your Elixir development team's productivity, with practical frameworks for addressing technical debt before it becomes critical.

Learn how dependency analysis transforms Elixir development decisions, with practical frameworks for evaluating long-term costs in Phoenix applications and OTP systems.

Discover how one simple question transforms Elixir development teams by creating psychological safety, enabling better collaboration, and preventing costly technical mistakes.

Learn how asking 'How will we know it works?' transforms Elixir development from feature delivery to business impact, with practical observability strategies.

Learn the 3 critical questions that transform Elixir development teams from code producers to business problem solvers, based on 20+ years of consulting experience.