elixir-pro
Expert guidance for idiomatic Elixir development, concurrency, and Phoenix application architecture.
Install
mkdir -p .claude/skills/elixir-pro && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/2632" && unzip -o skill.zip -d .claude/skills/elixir-pro && rm skill.zipInstalls to .claude/skills/elixir-pro
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Write idiomatic Elixir code with OTP patterns, supervision trees, and Phoenix LiveView. Masters concurrency, fault tolerance, and distributed systems.Key capabilities
- →Apply OTP patterns (GenServer, Supervisor, Application)
- →Implement Phoenix framework and LiveView features
- →Utilize Ecto for database interactions and changesets
- →Employ pattern matching and guard clauses
- →Design with processes for isolation and concurrency
- →Optimize performance on the BEAM VM
How it works
The skill embraces the "let it crash" philosophy, uses pattern matching, and designs with processes for isolation and concurrency. It also use immutability for predictable state.
Inputs & outputs
When to use elixir-pro
- →Design supervisor trees
- →Refactor GenServer logic
- →Implement Phoenix LiveView features
- →Optimize BEAM performance
About this skill
Use this skill when
Implement or review Elixir/OTP supervision, process concurrency, Phoenix/Ecto boundaries, failure recovery and ExUnit coverage.
Do not use this skill when
- The task is unrelated to elixir pro
- You need a different domain or tool outside this scope
Instructions
- Read actual project/runtime versions, current instructions and existing code before choosing changes; clarify only indispensable unknowns.
- Apply relevant best practices and validate outcomes.
- Provide actionable steps and verification.
You are an Elixir expert specializing in concurrent, fault-tolerant, and distributed systems.
Focus Areas
- OTP patterns (GenServer, Supervisor, Application)
- Phoenix framework and LiveView real-time features
- Ecto for database interactions and changesets
- Pattern matching and guard clauses
- Concurrent programming with processes and Tasks
- Distributed systems with nodes and clustering
- Performance optimization on the BEAM VM
Approach
- Use supervision for expected failure isolation; choose restart intensity/strategy deliberately and handle persistent invalid input or side effects explicitly
- Use pattern matching over conditional logic
- Design with processes for isolation and concurrency
- Leverage immutability for predictable state
- Test with ExUnit, focusing on property-based testing
- Profile with :observer and :recon for bottlenecks
Output
- Idiomatic Elixir following community style guide
- OTP applications with proper supervision trees
- Phoenix apps with contexts and clean boundaries
- ExUnit tests with doctests; use async only when fixtures/state are genuinely isolated
- Dialyzer specs for type safety
- Performance benchmarks with Benchee
- Telemetry instrumentation for observability
Follow Elixir conventions. Design for fault tolerance and horizontal scaling.
Example
User request:
Review this Elixir implementation for correctness, idiomatic design, performance, and test coverage.
Limitations
- This single-file guide is the available local procedure; no external reference pack or implementation-playbook is bundled or required. Keep existing framework/version constraints and report real verification separately from proposed code.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
How it compares
This skill focuses on idiomatic Elixir code with OTP patterns and fault tolerance, providing a structured approach to building concurrent and distributed systems, unlike generic programming practices.
Compared to similar skills
elixir-pro side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| elixir-pro (this skill) | 2 | 7mo | No flags | Advanced |
| software-architecture | 333 | 10mo | No flags | Intermediate |
| codex | 32 | 5mo | Review | Advanced |
| game-development | 70 | 10mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by sickn33
View all by sickn33 →You might also like
software-architecture
davila7
Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.
codex
Lucklyric
Invoke Codex CLI for complex coding tasks requiring high reasoning capabilities. This skill should be invoked when users explicitly mention "Codex", request complex implementation challenges, advanced reasoning, or need high-reasoning model assistance. Automatically triggers on codex-related requests and supports session continuation for iterative development.
game-development
davila7
Game development orchestrator. Routes to platform-specific skills based on project needs.
senior-fullstack
davila7
Comprehensive fullstack development skill for building complete web applications with React, Next.js, Node.js, GraphQL, and PostgreSQL. Includes project scaffolding, code quality analysis, architecture patterns, and complete tech stack guidance. Use when building new projects, analyzing code quality, implementing design patterns, or setting up development workflows.
command-name
anthropics
This skill should be used when the user asks to "create a plugin", "scaffold a plugin", "understand plugin structure", "organize plugin components", "set up plugin.json", "use ${CLAUDE_PLUGIN_ROOT}", "add commands/agents/skills/hooks", "configure auto-discovery", or needs guidance on plugin directory layout, manifest configuration, component organization, file naming conventions, or Claude Code plugin architecture best practices.
python-project-structure
wshobson
Python project organization, module architecture, and public API design. Use when setting up new projects, organizing modules, defining public interfaces with __all__, or planning directory layouts.