This is the full developer documentation for phxagents # phxagents > Iron Laws and specialist agents for Elixir/Phoenix in your AI coding tool. **Your AI coding tool is great. But it doesn’t know that `assign_new` silently skips on reconnect, that `:float` will corrupt your money fields, or that your Oban job isn’t idempotent.** This plugin does. It coordinates **21 specialist agents** that plan, implement, review, and verify your Elixir/Phoenix code in parallel — each with fresh context, domain expertise, and enforced [Iron Laws](/iron-laws/) that catch the bugs your tests won’t. 43 skills auto-load based on the file you’re editing, so there’s no prompt engineering and no `/load` commands. Currently shipping for **Claude Code** at v2.8.8; Codex, OpenCode, and Pi support landing in v3.0.0. phxagents · workflow $ /phx:plan Add real-time comments → 4 research agents started · 3 codebases · 12 sources → synthesising structured plan… ✓ plan written: plans/2026-05-08-comments.md $ /phx:work plans/2026-05-08-comments.md → implementing 6 tasks · Iron Laws active · 3 specialists → ecto schema · liveview component · oban worker… ✓ all tests pass · mix compile clean · zero warnings $ /phx:review → 4 review agents (security · ecto · liveview · oban) → checking 23 files against 22 Iron Laws… ✓ 0 findings · ready to ship Latest · v2.8.8May 8, 2026 ### v2.8.8 — /phx:mix-compression skill + Retention\@K convergence (#40) \- \*\*\`/phx:mix-compression\` skill\*\* (issue #40, Angle 1) — installs \[rtk]\(https\://github.com/rtk-ai/rtk) filters that compress \`mix test/credo/dialyzer/compile/deps.get/ecto.migrate\` output before it reaches the transcript. Bundled \`refer… [Read release notes →](https://github.com/oliver-kriska/claude-elixir-phoenix/releases/tag/v2.8.8) 43 skills auto-loaded for the file you're editing 21 specialist agents — planners, reviewers, investigators 22 Iron Laws — production-tested rules that catch bugs before they ship 104 deep-dive references for Phoenix, Ecto, LiveView, Oban, OTP ## Where it runs | AI coding tool | Status | Notes | | --------------- | ---------------- | ------------------ | | **Claude Code** | ✓ shipped | v2.x — full plugin | | **Codex CLI** | ◔ in development | landing v3.0.0 | | **OpenCode** | ◔ in development | landing v3.0.0 | | **Pi** | ◔ in development | landing v3.0.0 | ## How it works [Section titled “How it works”](#how-it-works) Auto-loaded skills Open a `*_live.ex` file → LiveView patterns load. Editing a migration → Ecto patterns. Auth code → Security Iron Laws. No `/load` commands. No prompt engineering. Specialist agents `/phx:plan` runs 4 research agents in parallel. `/phx:review` runs 4 review agents. Each has fresh context and domain expertise. The orchestrator synthesises. Iron Laws enforcement 22 non-negotiable rules: no `:float` for money, always `assign_async` in mount, never `String.to_atom` with user input. Verified at edit time and at review. Plan → Work → Review → Compound Filesystem is the state machine. Plans live as checkbox markdown. Reviews produce findings, not source edits. Solved problems become reusable knowledge. ## Start with these Four core workflow skills and four flagship orchestrators. Browse [all 43 skills](/skills/) or [all 21 agents](/agents/). ### Workflow skills [phx: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. → ](/skills/plan/)[phx: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. → ](/skills/work/)[phx:review Review code with parallel agents — tests, security, Ecto, LiveView, Oban. Use after implementation to catch bugs and anti-patterns before committing. → ](/skills/review/)[phx:full Use for large features spanning multiple contexts, new domain modules, or when the user wants autonomous end-to-end implementation. Runs the full plan-implement-review-compound cycle with specialist agents and Iron Laws enforcement. →](/skills/full/) ### Orchestrators & reviewers [workflow-orchestrator Orchestrates the full agentic workflow cycle (plan → work → review). Internal use by /phx:full command. → ](/agents/workflow-orchestrator/)[parallel-reviewer Parallel code review using 4 specialist agents (elixir-reviewer, security-analyzer, testing-reviewer, verification-runner). Use for thorough review of significant changes. → ](/agents/parallel-reviewer/)[iron-law-judge Checks code for Iron Law violations using pattern analysis. Use proactively after code changes or as part of review. → ](/agents/iron-law-judge/)[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. →](/agents/phoenix-patterns-analyst/) ## Get started [Section titled “Get started”](#get-started) Run these in Claude Code, one at a time. Each block has its own copy button. ```text /plugin marketplace add oliver-kriska/claude-elixir-phoenix ``` ```text /plugin install elixir-phoenix ``` [Full install guide →](/install/) # Changelog > phxagents plugin release notes. Current version: **v2.8.8**. The full changelog lives at [`CHANGELOG.md`](https://github.com/oliver-kriska/claude-elixir-phoenix/blob/main/CHANGELOG.md) in the plugin repo. Per-version pages auto-render here in the next site update. ## Latest releases [Section titled “Latest releases”](#latest-releases) See the [GitHub releases page](https://github.com/oliver-kriska/claude-elixir-phoenix/releases) for tagged releases with notes. ## Versioning [Section titled “Versioning”](#versioning) The plugin uses [semantic versioning](https://semver.org/): * **MAJOR** — breaking changes (workflow redesign, removed commands) * **MINOR** — new features (new hooks, skills, agents, commands) * **PATCH** — bug fixes, doc updates, description improvements You only receive updates when the version in `plugin.json` changes — push without a version bump and existing users won’t see the changes due to caching. # Install > How to install the phxagents plugin in Claude Code. The phxagents plugin currently ships for **Claude Code**. Multi-agent support (Codex, OpenCode, Pi) is in active development — see the [GitHub repo](https://github.com/oliver-kriska/claude-elixir-phoenix) for status. ## Claude Code [Section titled “Claude Code”](#claude-code) ```bash # Add the marketplace /plugin marketplace add oliver-kriska/claude-elixir-phoenix # Install the plugin /plugin install elixir-phoenix ``` The plugin auto-loads relevant skills based on the file you’re editing. No configuration required. ### What gets installed [Section titled “What gets installed”](#what-gets-installed) * 20+ specialist agents (orchestrators, reviewers, architects) * 40+ skills with progressive disclosure (Iron Laws inline, references on demand) * Hooks that auto-format Elixir, verify Iron Laws, detect debug statements * Tidewave MCP integration for runtime introspection ### After install [Section titled “After install”](#after-install) Run `/phx:intro` for a guided 6-section walkthrough, or jump straight in: ```bash /phx:plan Add a unique constraint on the email column ``` ## Coming soon [Section titled “Coming soon”](#coming-soon) | Agent | Status | Install | | ----------- | -------------- | ------------------------------------- | | Claude Code | ✓ shipped | `oliver-kriska/claude-elixir-phoenix` | | Codex | in development | TBD | | OpenCode | in development | TBD | | Pi | in development | TBD | Track progress in [issue #45](https://github.com/oliver-kriska/claude-elixir-phoenix/issues/45). # Iron Laws > Non-negotiable rules that prevent the bugs Elixir tests don't catch. The phxagents plugin enforces **22 Iron Laws** — non-negotiable patterns extracted from production Phoenix codebases. Each rule prevents a class of bugs that tests rarely catch. When code would violate a law, the plugin **stops and explains** before proceeding. ## Where they live [Section titled “Where they live”](#where-they-live) Iron Laws are defined in [`CLAUDE.md`](https://github.com/oliver-kriska/claude-elixir-phoenix/blob/main/CLAUDE.md) and inlined into every relevant skill so agents see them at decision time. After multi-agent port Phase 2D, they migrate to `plugins/elixir-phoenix/iron-laws/laws.yaml` as the single source of truth across Claude Code, Codex, OpenCode, and Pi. ## Categories [Section titled “Categories”](#categories) * **LiveView** — mount lifecycle, async data, streams, PubSub subscription guards * **Ecto** — money types, query interpolation, joins, preloads, deduplication * **Oban** — idempotency, arg shapes, struct hygiene * **Security** — atom exhaustion, authorization, raw HTML * **OTP** — process discipline, supervision * **Verification** — never claim done without proof ## Auto-derived enforcement [Section titled “Auto-derived enforcement”](#auto-derived-enforcement) Each Iron Law has: 1. A **detection pattern** (regex or AST match) hooked into PostToolUse 2. A **fix template** showing the correct pattern 3. A **stop directive** that interrupts the agent before the violation lands The full list is the canonical [`CLAUDE.md`](https://github.com/oliver-kriska/claude-elixir-phoenix/blob/main/CLAUDE.md#iron-laws-enforcement-non-negotiable) section. A site-rendered aggregator with each law’s source skill and detection pattern lands in the next site update.