using-elixir-skills

Use when writing Elixir, Phoenix, or OTP code - routes to the correct thinking skill before any code is written

⭐52stars🔀3forks📁View on GitHub🕐Updated Jan 3, 2026⬇️1downloads

When & Why to Use This Skill

This specialized Claude skill serves as an intelligent orchestration layer for Elixir, Phoenix, and OTP development. It enforces a 'thinking-first' workflow by routing tasks to domain-specific sub-skills before any code exploration or generation begins. By prioritizing architectural patterns and paradigm-specific logic, it ensures high-quality, idiomatic code while proactively preventing common anti-patterns such as process bottlenecks or inefficient LiveView mounting.

Use Cases

  • 1. Intelligent Task Routing: Automatically identifies whether a task requires general Elixir patterns, Phoenix web logic, or Ecto database interactions to provide the most relevant architectural context.
  • 2. Anti-Pattern Prevention: Acts as a guardrail to stop the AI from making common mistakes, such as using GenServers for simple code organization or performing heavy queries inside Phoenix mount functions.
  • 3. Concurrency Design: Guides the correct implementation of OTP behaviors, ensuring the use of Task.Supervisor for production-ready async jobs instead of simple Task.async calls.
  • 4. Background Job Orchestration: Provides specialized guidance for Oban-based workflows, including job queues, background processing, and complex async job architectures.
nameusing-elixir-skills
descriptionThis skill should be used when the user works on any .ex or .exs file, mentions Elixir/Phoenix/Ecto/OTP, the project has a mix.exs, or asks "which skill should I use", "new to Elixir", "help with Elixir". Routes to the correct thinking skill BEFORE exploring code. Triggers on "implement", "add", "fix", "refactor" in Elixir projects.
If the task involves Elixir, Phoenix, or OTP code, you MUST invoke the relevant skill BEFORE doing ANYTHING else—including exploring the codebase.

THIS IS NOT OPTIONAL. Skills tell you HOW to explore and WHAT to look for. You cannot rationalize your way out of this.

The Rule

Elixir/Phoenix/OTP task → Invoke skill FIRST → Then explore/research → Then write code

Skills come before exploration. The skills tell you what patterns to look for, what questions to ask, and what anti-patterns to avoid. Exploring without the skill means you don't know what you're looking for.

Skill Triggers

Trigger Phrases Skill to Invoke
code, implement, write, design, architecture, structure, pattern elixir-thinking
LiveView, Plug, PubSub, mount, channel, socket, component phoenix-thinking
context, schema, Ecto, changeset, preload, Repo, migration ecto-thinking
GenServer, supervisor, Task, ETS, bottleneck, Broadway otp-thinking
Oban, workflow, job queue, cascade, graft, background job, async job oban-thinking

Red Flags

These thoughts mean STOP—invoke the skill:

Thought Reality
"Let me explore the codebase first" Skills tell you WHAT to look for. Invoke first.
"Let me understand the code first" Skills guide understanding. Invoke first.
"But first, let me..." No. Skills come first. Always.
"I'll add a process to organize this" Processes are for runtime, not organization.
"GenServer is the Elixir way" GenServer is a bottleneck by design.
"I'll query in mount" mount is called twice.
"Task.async is simpler" Use Task.Supervisor in production.
"I know Elixir well enough" These skills contain paradigm shifts. Invoke them.