OpenClaw Skills for Elixir and Phoenix Developers

Elixir and Phoenix occupy a unique position in the web development landscape. The combination of functional programming, the BEAM virtual machine, OTP patterns, and Phoenix's real-time capabilities creates a stack that is powerful but distinct from anything else. AI agents trained primarily on mainstream languages often struggle with Elixir's idioms — pattern matching in function heads, pipe operators, supervision trees, and the actor model all require specific knowledge.

OpenClaw skills bridge this gap by giving your agent focused Elixir and Phoenix expertise. Instead of getting Ruby-influenced code that happens to compile, you get idiomatic Elixir that leverages the platform's strengths.

This guide covers the best Elixir and Phoenix skills available in the OpenClaw Bazaar skills directory.

Phoenix LiveView Skills

Phoenix LiveView has changed how developers build interactive web applications with Elixir. Server-rendered real-time UIs without writing JavaScript — but only if your agent understands the lifecycle.

liveview-patterns (7,600 installs)

This is the most popular Elixir skill on the Bazaar. It teaches your agent to build LiveView modules with proper lifecycle callbacks: mount/3, handle_params/3, handle_event/3, and handle_info/2. The skill covers assigns management, temporary assigns for large lists, and the stream API for efficient DOM updates introduced in LiveView 0.19.

Where this skill really helps is with the HEEx template syntax. Agents without LiveView training frequently produce templates that mix up <.component> function component syntax with <Component> stateful component syntax, or forget that LiveView templates use @assigns instead of passing data through function arguments. The skill eliminates these mistakes.

It also covers LiveView navigation — push_navigate, push_patch, and the difference between them — which is one of the most common sources of confusion for developers and agents alike.

liveview-components (5,100 installs)

Building reusable components in LiveView has its own set of patterns. This skill teaches your agent to create function components with attr/3 and slot/2 declarations, build stateful components with live_component, and handle component communication through the parent LiveView process. It covers the Phoenix.Component module and the declarative assigns validation that catches errors at compile time.

The slot system gets special attention. Named slots with custom attributes are powerful but syntactically dense, and agents without specific training tend to produce slot markup that fails to compile. This skill provides clear patterns your agent can follow.

liveview-uploads (3,400 installs)

File uploads in LiveView use a unique approach — allow_upload/3, consume_uploaded_entries/3, and client-side hooks for drag-and-drop. This skill teaches your agent to implement direct-to-cloud uploads with presigned URLs, progress tracking, file validation, and the auto-upload pattern. It is a focused skill that complements liveview-patterns for applications that handle file uploads.

Ecto Skills

Ecto is not just an ORM — it is a toolkit for data mapping, validation, and query composition. Its explicit approach to database interaction requires agents to think differently from ActiveRecord or other convention-heavy ORMs.

ecto-expert (9,200 installs)

This comprehensive skill covers Ecto schemas, changesets, queries, and migrations. It teaches your agent to define schemas with proper field types and associations (has_many, belongs_to, many_to_many with join tables), build changeset pipelines with cast/3, validate_required/2, and custom validators, and compose queries using Ecto's query syntax.

The query composition guidance is particularly valuable. Ecto's pipe-based query building — where you chain from, where, join, select, and preload clauses — is elegant but has specific rules about binding variables and referencing associations. Agents frequently produce queries with incorrect binding syntax or try to use Elixir variables inside query macros without ^ pinning. This skill prevents those errors.

ecto-multi-transactions (4,300 installs)

Ecto.Multi provides a way to compose multiple database operations into a single transaction with named steps. This skill teaches your agent to build Multi pipelines with Multi.insert/4, Multi.update/4, Multi.run/3 for arbitrary operations, and error handling that gives meaningful feedback about which step failed. It is essential for any application that needs transactional consistency across multiple database operations.

ecto-migrations-advanced (3,100 installs)

Beyond basic add_column and create_table, Ecto migrations support data migrations, concurrent index creation, and reversible operations. This skill teaches your agent to write migrations that handle production concerns: using execute/1 for raw SQL when Ecto's DSL is insufficient, creating indexes with concurrently: true to avoid table locks, and structuring data migrations so they can run on large tables without downtime.

GenServer and OTP Patterns

OTP is what makes Elixir special. GenServers, Supervisors, and the supervision tree architecture give Elixir applications fault tolerance that most other platforms cannot match.

genserver-otp-patterns (8,400 installs)

This skill teaches your agent to implement GenServer modules with proper callback functions: init/1, handle_call/3, handle_cast/2, and handle_info/2. It covers state management within GenServer processes, timeout handling, and the naming and registration patterns that let processes find each other.

Beyond individual GenServers, the skill covers supervision tree design. It teaches your agent when to use :one_for_one, :one_for_all, and :rest_for_one supervision strategies, how to structure child specs, and how to use DynamicSupervisor for processes that are started and stopped at runtime. This is critical knowledge — a poorly structured supervision tree undermines the fault tolerance that makes OTP valuable in the first place.

otp-task-agent (3,700 installs)

Not every concurrent operation needs a full GenServer. This skill teaches your agent when to use Task, Task.Supervisor, and Agent instead. It covers Task.async/1 and Task.await/1 for one-off parallel work, Task.Supervisor.async_nolink/2 for fire-and-forget jobs, and Agent for simple state wrappers. Knowing which OTP primitive to reach for is a skill in itself, and this extension gives your agent that judgment.

ExUnit Testing Skills

Elixir's built-in ExUnit framework is simple but has patterns that agents need to know.

exunit-testing-elixir (6,900 installs)

This skill covers ExUnit testing from basic test blocks through advanced patterns. It teaches your agent to write tests with proper setup using setup and setup_all callbacks, use describe blocks for grouping, and leverage pattern matching in assertions with assert, refute, and assert_receive for process message testing.

For Phoenix-specific testing, the skill covers ConnTest for controller and endpoint tests, DataCase for Ecto-dependent tests with the Sandbox adapter, and LiveViewTest for testing LiveView interactions with render_click, render_change, and render_submit. The LiveView testing API is unlike anything in other frameworks, and agents without this skill consistently produce tests that do not compile.

mox-testing-patterns (4,500 installs)

The Elixir community favors behavior-based mocking with the Mox library over traditional mock objects. This skill teaches your agent to define behaviors (callback modules), set up Mox expectations with expect/3 and stubs with stub/3, and configure the test environment to use mock implementations via application configuration. It also covers the pattern of using Mox.verify_on_exit!/1 in setup blocks and organizing mock definitions in test/support/mocks.ex.

Deployment Skills

Deploying Elixir applications involves OTP releases, which have their own build and configuration model.

elixir-release-deploy (5,600 installs)

This skill teaches your agent to configure Mix releases with config/runtime.exs for runtime configuration, build releases with mix release, and structure Dockerfiles for multi-stage Elixir builds. It covers the release configuration options — cookie setting, node naming, and environment variable injection — and the common deployment patterns for platforms like Fly.io, Gigalixir, and bare-metal servers.

The Docker guidance is especially useful. Elixir release Dockerfiles have specific requirements around the Erlang/OTP and Elixir version matching between build and runtime stages, and agents without this skill frequently produce Dockerfiles that fail at runtime due to missing ERTS or NIF compatibility issues.

elixir-clustering (2,800 installs)

For applications that run multiple nodes — which unlocks distributed features like distributed PubSub and Horde — this skill teaches your agent to configure node clustering with libcluster, set up distributed Phoenix PubSub, and handle the networking requirements for clustering on Kubernetes and Fly.io. It is a specialized skill for production deployments that need horizontal scaling.

Getting Started

For a new Phoenix LiveView project, install liveview-patterns, ecto-expert, genserver-otp-patterns, and exunit-testing-elixir as your baseline. That combination covers the core of most Elixir web applications. Add specialized skills as your project grows — liveview-uploads when you need file handling, ecto-multi-transactions when your business logic requires transactional workflows, and elixir-release-deploy when you are ready for production.

Browse the full collection of Elixir and Phoenix skills in the OpenClaw Bazaar skills directory.

Browse the Skills Directory

Find the right skill for your workflow. The OpenClaw Bazaar skills directory has over 2,300 community-rated skills — searchable, sortable, and free to install.

Browse Skills →

Built a Skill? List It on the Bazaar

If you have built a skill that others would find useful, publish it on the Bazaar. Reach thousands of developers and get feedback from the community.

Learn how to publish →