Elixir plugins

Build and debug Membrane multimedia processing pipelines in Elixir, with guidance on creating custom Elements, Bins, and Filters and understanding the framework architecture.

Scaffold Backpex LiveResources, filters, custom fields, resource actions, and item actions for Phoenix admin panels in Elixir apps. Perform guided Backpex upgrades by applying changelogs and version bumps. Connect MCPs for local Chrome DevTools browser automation and remote AI model context management.

Automate full-cycle Elixir/Phoenix/LiveView development: use /phx: commands and specialist agents to brainstorm/plan features, implement changes, audit architecture/performance/security, debug bugs/Ecto/Oban issues, review PRs, verify with mix tools/tests, compound solutions into docs, and deploy to Docker/Fly.io.

Enforce idiomatic Elixir and Phoenix LiveView best practices across code quality, Ecto schemas and changesets, OTP behaviors, authentication flows, security rules, deployment configs, PubSub patterns, file uploads, Oban jobs, telemetry, and testing via targeted skills for analysis and refactoring, plus agents for project structure, Ecto conventions, LiveView checklists, and testing guides.

Develop Elixir applications in Claude Code with expert LSP support for .ex, .exs, .heex, and .leex files, providing diagnostics, go-to-definition, find references, hover info, and symbol listing to streamline navigation and error detection.

Develop scalable Elixir and Phoenix apps using guided expert patterns for Ecto data layers with DDD pipelines, Oban job workflows, OTP concurrency avoiding GenServer pitfalls, secure LiveView practices, and functional programming shifts from OOP.

Query Hex package docs for modules, functions, examples from local deps or API, and extract conventions/patterns from usage-rules.md in Elixir projects like Phoenix/Ecto/Ash. Securely execute tools by blocking Bash/WebFetch network egress, restricting file writes outside review dirs, and validating CVEs post-use.

Access documentation, source code, examples, best practices, patterns, conventions, and common mistakes for Elixir Hex packages like Phoenix, Ecto, Ash, and Credo from local dependencies or by fetching as needed. Secure automation with hooks that block network egress in tools, restrict file writes, execute bash scripts safely, and validate CVE IDs post-tool use.

Interact with databases in Elixir apps using Ecto: define schemas with fields, associations, and embeds; build queries via Ecto.Query DSL for filtering, joining, aggregating, and preloading; validate, cast, and transform data with changesets before inserts and updates.

Build Phoenix Framework web applications in Elixir by implementing controllers for HTTP request handling and rendering, defining routes with URL helpers and pipelines, applying context patterns and plugs, and rendering dynamic HEEx templates with assigns, conditionals, loops, and components.

Run Credo static code analysis on Elixir projects to check for code quality issues, style violations, refactoring opportunities, and potential security problems. Security hooks automatically block network egress in Bash and WebFetch tools, restrict file writes to review directories, and validate CVE IDs after tool use.

Securely execute Sobelow for static security analysis on Phoenix and Elixir projects, using pre-tool hooks to block network egress in Bash and WebFetch tools plus file writes outside directories, and post-tool validation of CVE IDs.

Configure Credo static analysis for Elixir projects via .credo.exs setups with custom rules for design, readability, and refactoring. Explain and fix issues like missing module docs, function complexity, long pipe chains, unused variables. Build project-specific checks to detect secrets and enforce tailored quality. Integrate hooks for async formatting and testing workflows.

Detect, analyze, and fix Dialyzer type warnings and specs in Erlang/Elixir codebases, set up static analysis configs and PLTs, integrate into CI/CD pipelines with GitHub Actions, VS Code, pre-commit hooks, and automate analysis scripts on session events.

Develop concurrent, fault-tolerant Gleam backends on the BEAM VM using OTP actor patterns like GenServers and supervisors, integrate Erlang libraries with type-safe interop via NIFs and ports, apply advanced type system features including ADTs and pattern matching, and edit code intelligently with LSP diagnostics, navigation, hovers, and symbols.

Develop robust Elixir backends with OTP patterns for concurrent GenServers, Supervisors, Agents, Tasks and fault-tolerance; Ecto patterns for schemas, changesets, queries, associations, transactions; pattern matching for functions, cases, guards, destructuring. Leverage expert LSP for diagnostics, go-to-definition, references, hover info, symbols in .ex/.exs files.

Design GraphQL schemas with custom types and interfaces, implement efficient resolvers using Dataloader for N+1 prevention, batching, middleware, and error handling, and set up real-time subscriptions in Elixir Phoenix apps with Absinthe.

Automate specialized code reviews for Elixir, Phoenix, and LiveView applications, analyzing idiomatic style, OTP patterns, performance bottlenecks like GenServer issues and N+1 queries, security vulnerabilities such as atom exhaustion, ExDoc documentation coverage, and ExUnit test quality. Orchestrate parallel reviews on changed code after linting, with verification to minimize false positives.

Run the Elixir language server to enable autocomplete, real-time diagnostics, go-to-definition, hover documentation, find references, and refactoring tools for Elixir development in your coding environment.

Automatically runs `mix compile --warnings-as-errors` after editing Elixir files, treating warnings as errors to enforce strict compilation standards instantly. Edit code in Claude Code with immediate feedback on warnings, preventing them from slipping into your Elixir projects without manual checks.

Automatically formats Elixir files using mix format after Edit, Write, or MultiEdit operations, keeping your code consistently styled and clean without manual formatting steps.

Bulk-installs all 71 marketplace skills into Claude Code, instantly enabling expert guidance for git workflows, devops automation (mise/Dagu/act), backend development (Elixir Phoenix/OTP/Rust async/Zig C-interop), frontend/UI (Slidev/daisyUI), TDD/testing/security scans, documentation, and plugin creation without hunting individual plugins.

Automatically runs mix credo to lint and check code quality on Elixir files right after Edit, Write, or MultiEdit operations, ensuring issues are caught instantly without manual invocation.

Delegate complex coding workflows to AI agents equipped with skills for creating detailed project plans and specs, designing production-grade React/Next.js/Tailwind UIs, simplifying/refactoring code, writing tests and docs, smart git commits, browser automation, Elixir backend features, and step-by-step plan execution with human oversight.

Develop and debug Elixir Phoenix apps using specialized AI skills for OTP concurrency, configuration management, idiomatic style and anti-pattern refactoring, ExUnit testing, ports for external processes, plus Tidewave agent for live introspection of schemas, SQL queries, docs, logs, and code execution.

Develop WebAssembly apps with Wasmtime by compiling Rust/Zig guests for embedding in Rust/Elixir hosts using WASI, author WIT files defining Component Model interfaces mappable to Rust/Go/Python/JS via cargo-component and wit-bindgen, and inspect .wasm binaries for validity, structure, imports/exports, and WIT interfaces.

Write idiomatic Elixir code with OTP supervision trees, Phoenix LiveView, concurrency, fault tolerance, and distributed systems. Refactor existing codebases and optimize for BEAM performance using best practices.

Execute full SDLC workflows: initialize with GitHub CLI/git-spice setup, design event-sourced domains via Event Modeling, enforce strict Red-Green-Domain TDD cycles with mutation testing and primitive obsession audits in Rust/JS/TS/Python/Go/Elixir projects, manage ADRs, stacked PRs, code reviews, and issue tracking.

Automate end-to-end development workflows in Claude Code: run multi-agent code reviews, performance/security/accessibility audits, test suite analysis, git PR/changelog/branch management, dependency pruning, dead code removal, docs sync, and agent-driven refactoring/DB optimization for JS/Python/Elixir/Rust projects.

Automate end-to-end project workflows with parallel Claude agents: discover codebase structure, tech stack, and architecture; generate PRDs, phased plans, and task breakdowns; execute implementations; produce READMEs, API docs, and guides; run code quality assessments and STRIDE security reviews.