elixir-phoenix

Plugin elixir-phoenix from marketplace oliver-kriska in oliver-kriska/claude-elixir-phoenix. Commands read from the repo's manifest — 10 days ago.

Skills (50)

• ash-framework

  Ash Framework — resources, actions, policies, aggregates, calculations, AshPhoenix.Form, LiveView, migrations. Use when generating resources via mix ash.codegen, editing changes, checks, types, validations, or domain code interfaces.

• assigns-audit

  Inspect LiveView socket assigns for memory bloat — missing temporary_assigns, unused assigns, unbounded lists needing streams, memory estimates. Use when LiveView memory grows or you need to add temporary_assigns.

• audit

  Project health audit and health check — architecture, performance, tests, dependencies, code quality. Use when assessing overall project health, before releases, or after refactors.

• boundaries

  Analyze Phoenix context boundaries and module coupling via mix xref. Use when checking cross-context calls, validating dependencies, before splitting modules, or reviewing architecture.

• brainstorm

  Brainstorm Elixir/Phoenix features — explore ideas, compare approaches, gather requirements. Use when vague idea, not sure how to approach, or want to discuss before plan.

• brief

  Interactive briefing of a plan file — explains reasoning, schema decisions, component choices. Use when developers need to understand a plan before approving.

• challenge

  Challenge mode reviews - rigorous questioning before approving changes. Use when you want thorough scrutiny of Ecto changes, LiveView events, OTP designs, or PR readiness.

• codex-loop

  Fix Elixir/Phoenix code until Codex CLI review comes back clean — bounded review, fix, verify loop before opening a PR. Use when codex is installed and you want an external cross-model critic on your changes before pushing.

• compound-docs

  Searchable Elixir/Phoenix/Ecto solution documentation system with YAML frontmatter. Builds institutional knowledge from solved problems. Use when consulting past solutions before investigating new issues.

• compound

  Capture solved problems as searchable solution docs. Use after fixing bugs, when "that worked", or after successful /phx:review or /phx:investigate.

• deploy

  Elixir/Phoenix deployment patterns — Dockerfile, fly.toml, runtime.exs, mix release, rel/ overlays. Use when configuring Fly.io, Docker, CI/CD, health checks, or production migrations.

• deps-audit

  Audit Hex deps for supply-chain security risk — bidi chars, compile-time exec, maintainer changes, typosquats, CVEs. Use after mix deps.update, when checking if a package upgrade is safe, or reviewing mix.lock PR diffs.

• deps-update

  Bump outdated Hex deps — inventory, snapshot changelogs, update, fix breaks, split reviewable PRs (patches bundled, majors solo). Use to upgrade/bump Elixir dependencies or when versions fall behind. NOT for deps.get failures (/phx:investigate).

• deps-vet

  Record a vetted Hex package version in hex_vet.exs after a security review — manages the audit ledger, not the scanner. Use to approve a dep after /phx:deps-audit findings or to initialize hex_vet.exs.

• document

  Use when asked to document Elixir code: add or fill in @moduledoc and @doc for modules and functions. Documents tested code only; may add a README section or ADR. Not for docs lookup or audits.

• ecto-constraint-debug

  Debug Ecto constraint violations - trace triggers, check migrations, find duplicate data. Use when seeing unique_constraint, foreign_key_constraint, or check_constraint errors.

• ecto-patterns

  Use when a task touches Ecto, even a how-to question: schemas, changesets, validations, queries, preloads, Multi, migrations, constraints, money fields. Load it before writing Ecto code. Skip for Ash.

• elixir-idioms

  OTP/BEAM patterns and Elixir idioms — GenServer, Supervisor, Task, Registry, pattern matching, with chains, pipes. Use when designing processes or debugging BEAM issues.

• freeze

  Scope or freeze which files Claude can edit during debugging, a refactor, or review. Use when edits should stay in specific dirs, or for a read-only investigate lock. Backed by a sentinel + PreToolUse hook.

• full

  Deliver a large, cross-domain Phoenix feature or complete end-to-end system through planning, implementation, verification, and review. Use when several coordinated workflows or contexts must ship together. NOT for an existing plan; use /phx:work.

• help

  Use when the user asks which /phx: command fits a task (review, plan, debug, test) or how two commands differ. Checks plans and git state, then recommends from the routing table. Not for bare /help, a tour, or ambiguous requests (intent-detection).

• hexdocs-fetcher

  Fetch HexDocs for Elixir libraries with HTML-to-markdown conversion. Use when looking up docs on hexdocs.pm — modules, functions, guides, changelogs.

• init

  Initialize plugin in a project — install Iron Laws, auto-activation rules, and reference auto-loading into CLAUDE.md. Use when setting up or updating the plugin.

• intent-detection

  Route ambiguous or mixed Phoenix/LiveView/Ecto requests before choosing a workflow. Use when user is unsure where to start/how to approach work, asks for the right workflow, or combines intents such as fixing and refactoring. NOT for a clear task.

• intro

  Walk through the Elixir/Phoenix plugin commands, workflow, and features in 6 interactive sections. Use when a new user wants to learn what the plugin offers or needs a refresher on available commands.

• investigate

  Find the root cause of Elixir/Phoenix bugs — crashes, exceptions, stack traces, compile errors, LiveView that won't update, silent failures. Use when something is broken or misbehaves. --parallel for 4 tracks.

• learn-from-fix

  Capture Elixir/Ecto/LiveView lessons and Hex API rules. Use after corrections or when asked to document learning, record a lesson, prevent a fixed mistake, or remember package guidance with --library.

• liveview-patterns

  Build LiveView: async data (assign_async), PubSub (check connected?), phx-change events, form components/modals/uploads, streams for lists, live_patch. Use when handling interactions, debugging events, or tracking Presence.

• mix-compression

  Reduce mix output noise (5-15% token savings) by installing rtk filters that compress mix test/credo/dialyzer/compile output before it reaches Claude. Use when long mix output floods context.

• n1-check

  Detect N+1 query anti-patterns specifically — Repo calls inside Enum/for loops, missing preloads on associations. Use when N+1 is explicitly suspected, NOT for unrelated Ecto questions or wider database performance.

• narrow-bare-rescue

  Narrow bare rescue in Elixir so real errors like KeyError and typos propagate instead of being swallowed. Use to audit rescues and refactor error handling.

• oban

  Use when writing, scheduling, testing or debugging Oban jobs, even for a how-to question: workers, cron, retries, unique jobs, queues, Pro Workflow/Batch. Load it before touching job code; it holds the job rules.

• perf

  Use when anything in a Phoenix app is slow, times out, or uses too much memory, even if the cause looks obvious. Load it before analyzing or fixing: it runs measured Ecto, LiveView and OTP checks and ranks fixes.

• permissions

  Recommend safe Bash permissions for Elixir mix commands in settings.json. Use when permission prompts slow workflow, "fix permissions", "reduce prompts", "auto-allow mix".

• phoenix-contexts

  Phoenix context design — creating/splitting contexts, Scope (1.8+), Ecto.Multi, PubSub, routers, plugs, controllers. Use when editing contexts, routers, or designing boundaries.

• plan

  Plan features spanning multiple domains: billing (Stripe), auth (RBAC), real-time (Presence), webhooks, jobs (Oban). Use when designing interconnected systems or converting review findings into tasks.

• pr-review

  Address feedback left on a GitHub pull request: fetch unresolved review threads, make agreed Elixir/Phoenix code fixes, reply, and resolve. Use for a PR URL/number or reviewer comments. NOT for pre-PR review, findings triage, or CI monitoring.

• quick

  Implement small Phoenix changes without planning — add validations, update routes, fix components, create migrations. Use for single-file edits under 50 lines.

• recall

  Recall prior work from past sessions — how a bug was fixed, what was decided, where a pattern lives. Use when asked 'have we done this before' or 'how did I fix X' in Elixir/Phoenix work. ccrider MCP when available, else git + solution docs.

• research

  Research Elixir/Phoenix/Ecto topics or evaluate Hex libraries (--library). Use when learning about libraries, patterns, or comparing approaches. Searches HexDocs, ElixirForum, GitHub.

• review

  Review Elixir/Phoenix changes before committing — bugs, security, Ecto, LiveView, and Oban anti-patterns, via parallel specialist agents. Use when asked to review changes, a component, a diff, or a PR.

• security

  Build and harden Phoenix auth and security — OAuth login, password hashing, sessions, RBAC, rate limiting, CSRF, XSS, SQL injection, secrets. Use when adding login flows or permissions, or handling user input.

• techdebt

  Analyze Elixir/Phoenix technical debt — duplicates, refactoring opportunities, credo issues. Use when asked about code quality, cleanup, or what to improve.

• testing

  Write or repair Elixir tests with ExUnit, sandbox isolation, async reliability, Mox, ExMachina, and LiveViewTest. Use for test files, test setup, or failing/flaky tests. NOT for investigating an application bug outside the test suite.

• tidewave-integration

  Tidewave MCP runtime tools — debugging, smoke testing, live state inspection, SQL queries, hex docs. Use when evaluating code in a running Phoenix app.

• trace

  Use when debugging how a value or request reaches Elixir code, finding who calls a function, or planning a signature change. Builds the call tree with mix xref callers instead of reading files one by one.

• triage

  Triage review findings interactively — approve, skip, or prioritize each issue. Use after /phx:review to filter findings before fixing.

• verify

  Verify Elixir/Phoenix changes — compile, format, and test in one loop. Use after implementation, before PRs, or after fixing bugs.

• watch-pr

  Watch an Elixir/Phoenix PR for new review comments (bot + human) and CI results via a background watcher that wakes Claude only on real events. Use after opening a PR or pushing, while waiting on CI or reviewers.

• work

  Execute Elixir/Phoenix plan tasks with progress tracking. Use after /phx:plan to implement features with mix compile and mix test verification after each step, or --continue to resume interrupted work.

Subagents (26)

• ash-policy-reviewer

  Ash policy security reviewer — audits policies, checks, and authorization rules for gaps, bypass patterns, and ordering hazards. Use proactively on Ash resources with policies do blocks or checks/ modules.

• ash-query-optimizer

  Ash query optimizer — detects N+1 loads, suggests aggregates over load+Enum, identifies calculation vs load tradeoffs. Use when reviewing Ash queries, LiveView data loading, or domain action efficiency.

• ash-resource-designer

  Ash resource architect — designs resources the "Ash Way" with built-in changes, validations, types, and policy checks before hand-rolling. Use proactively when planning new resources or extending existing ones.

• call-tracer

  Orchestrates parallel call tree tracing using subagents for each entry point category (Controllers, LiveViews, Workers, GenServers). Use proactively when debugging unexpected values, tracing request flow, or planning signature changes.

• codex-reviewer

  Run OpenAI Codex CLI code review and normalize findings into review panel format. Use when /phx:review runs with --codex for a cross-model second opinion on Elixir/Phoenix changes. Requires codex CLI; degrades to SKIPPED note.

• context-supervisor

  Compresses multi-agent output into consolidated summaries to prevent context exhaustion. Generic — works for any orchestrator. Use after sub-agents complete and before parent synthesis.

• deep-bug-investigator

  Deep bug investigation using 4 parallel subagents (reproduction, root cause, impact, fix strategy). Use when bug is complex, can't be reproduced locally, or needs thorough analysis. Spawns fresh-context subagents for each investigation track.

• deployment-validator

  Deployment configuration validator - releases, Docker, Kubernetes, Fly.io. Use proactively before deploying to production.

• ecto-schema-designer

  Ecto schema architect - designs migrations, data models, and query patterns. Use proactively when planning database structure for new features.

• elixir-reviewer

  Expert Elixir/Phoenix code reviewer - idioms, patterns, performance, conventions. Use proactively after writing Elixir code.

• hex-deps-triager

  Triage Hex supply-chain audit findings in Elixir/Phoenix — review diff windows and metadata to produce structured security verdicts. Use after /phx:deps-audit.

• hex-library-researcher

  Researches Elixir libraries on hex.pm. Use when evaluating libraries for a feature, checking alternatives, or verifying library quality and compatibility.

• iron-law-judge

  Checks code for Iron Law violations using pattern analysis. Use proactively after code changes or as part of review.

• liveview-architect

  LiveView architecture specialist - component structure, real-time patterns, streams vs assigns, async patterns. Use proactively when planning interactive features.

• oban-specialist

  Oban worker specialist - reviews idempotency, error handling, and production safety. Use proactively when implementing or reviewing background jobs.

• otp-advisor

  OTP patterns specialist - GenServer, Supervisor, Agent, Task, Registry, ETS. Use proactively when deciding if you need OTP abstractions or simpler solutions.

• parallel-reviewer

  Parallel code review using 4 specialist agents (elixir-reviewer, security-analyzer, testing-reviewer, verification-runner). Use for thorough review of significant changes.

• phoenix-patterns-analyst

  Analyzes codebase for existing Phoenix patterns, contexts, module structure, scopes, plugs, and routing. Use proactively when planning features to understand current conventions.

• planning-orchestrator

  Fans out and compresses parallel Elixir/Phoenix planning research (codebase patterns, libraries, schema/OTP/LiveView design) into one digest. Use when /phx:plan needs 3+ research agents; returns findings only, never plans or asks the user.

• requirements-verifier

  Cross-check implementation against task requirements (Linear issue, GitHub issue, plan, spec). Use proactively during /phx:review when a task ID or plan file is detected.

• security-analyzer

  Security audit specialist for Elixir/Phoenix - authentication, authorization, input validation, OWASP vulnerabilities. Use proactively when implementing auth or handling user input.

• testing-reviewer

  Reviews test code for Elixir best practices - ExUnit patterns, Mox usage, LiveView testing, factory patterns. Use proactively after writing tests or during code review.

• verification-runner

  Run project-aware verification loop. Reads mix.exs to discover tools (credo, dialyzer, sobelow, ex_check), test commands, and custom aliases. Use proactively after code changes.

• web-researcher

  Fetches and extracts information from web sources efficiently. Optimized for ElixirForum, HexDocs, and GitHub. Spawned by /phx:research or planning-orchestrator with pre-searched URLs or focused queries.

• workflow-orchestrator

  Orchestrates the full agentic workflow cycle (plan → work → review). Internal use by /phx:full command.

• xref-analyzer

  Analyze module dependencies and context boundaries using mix xref. Use proactively before major refactors or when reviewing architectural changes.

Hooks (30)

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/format-elixir.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/format-elixir.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/iron-law-verifier.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/iron-law-verifier.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/debug-statement-warning.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/format-elixir.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/format-elixir.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/iron-law-verifier.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/iron-law-verifier.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/debug-statement-warning.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/plan-stop-reminder.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/security-reminder.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/log-progress.sh"

• PostToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/error-critic.sh"

• UserPromptSubmit

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/route-intent.sh"

• PreToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/block-dangerous-ops.sh"

• PreToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/deps-audit-gate.sh"

• PreToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/freeze-gate.sh"

• PostToolUseFailure

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/elixir-failure-hints.sh"

• PostToolUseFailure

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/error-critic.sh"

• SubagentStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/inject-iron-laws.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/setup-dirs.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/detect-tidewave.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/detect-ash.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/check-scratchpad.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/check-resume.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/check-branch-freshness.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/compact-rules.sh"

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/compact-verify.sh"

• StopFailure

  "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/stop-failure-log.sh"

Similar plugins