{"id":46940894,"url":"https://github.com/oliver-kriska/claude-elixir-phoenix","last_synced_at":"2026-04-08T09:02:25.098Z","repository":{"id":338569066,"uuid":"1156146412","full_name":"oliver-kriska/claude-elixir-phoenix","owner":"oliver-kriska","description":"Claude Code plugin for Elixir/Phoenix/LiveView — 20 specialist agents, Iron Laws enforcement, and Tidewave MCP integration. Plan features with parallel research agents, execute with automatic verification, review with 4-agent parallel audits, and capture learnings as reusable knowledge.","archived":false,"fork":false,"pushed_at":"2026-04-02T16:19:51.000Z","size":1301,"stargazers_count":174,"open_issues_count":8,"forks_count":14,"subscribers_count":6,"default_branch":"main","last_synced_at":"2026-04-02T23:15:50.494Z","etag":null,"topics":["automation","claude","claude-code","claude-code-plugin","claude-code-skills","claude-skills","elixir","elixir-lang","elixir-phoenix","phoenix","phoenix-framework","vibe-coding"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/oliver-kriska.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-02-12T10:09:18.000Z","updated_at":"2026-04-02T16:19:55.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/oliver-kriska/claude-elixir-phoenix","commit_stats":null,"previous_names":["oliver-kriska/claude-elixir-phoenix"],"tags_count":10,"template":false,"template_full_name":null,"purl":"pkg:github/oliver-kriska/claude-elixir-phoenix","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oliver-kriska%2Fclaude-elixir-phoenix","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oliver-kriska%2Fclaude-elixir-phoenix/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oliver-kriska%2Fclaude-elixir-phoenix/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oliver-kriska%2Fclaude-elixir-phoenix/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/oliver-kriska","download_url":"https://codeload.github.com/oliver-kriska/claude-elixir-phoenix/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/oliver-kriska%2Fclaude-elixir-phoenix/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31547846,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-07T16:28:08.000Z","status":"online","status_checked_at":"2026-04-08T02:00:06.127Z","response_time":54,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["automation","claude","claude-code","claude-code-plugin","claude-code-skills","claude-skills","elixir","elixir-lang","elixir-phoenix","phoenix","phoenix-framework","vibe-coding"],"created_at":"2026-03-11T07:02:48.239Z","updated_at":"2026-04-08T09:02:25.090Z","avatar_url":"https://github.com/oliver-kriska.png","language":"Python","funding_links":[],"categories":["Source Catalog","AI Coding Assistants and Skills"],"sub_categories":[],"readme":"# Elixir Phoenix Plugin for Claude Code\n\n**Claude Code 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.**\n\nThis plugin does. It coordinates **20 specialist agents** that plan, implement,\nreview, and verify your Elixir/Phoenix code in parallel -- each with domain\nexpertise, fresh context, and enforced [Iron Laws](#iron-laws-non-negotiable-rules)\nthat catch the bugs your tests won't.\n\n```bash\n# You describe the feature. The plugin figures out the rest.\n/phx:plan Add real-time comment notifications\n\n# 4 research agents analyze your codebase in parallel.\n# A structured plan lands in .claude/plans/comment-notifications/plan.md\n# Then:\n\n/phx:work .claude/plans/comment-notifications/plan.md\n# Implements task by task. Compiles after each change.\n# Stops cold if code violates an Iron Law.\n\n/phx:review\n# 4 specialist agents audit in parallel:\n# idioms, security, tests, compilation.\n# Deduplicates findings. Flags pre-existing issues separately.\n```\n\nNo prompt engineering. No \"please check for N+1 queries.\" The plugin auto-loads\nthe right domain knowledge based on what files you're editing and enforces rules\nthat prevent the mistakes Elixir developers actually make in production.\n\n```\n┌─────────────────────────────────────────────────────────────────────┐\n│  ⚗  Elixir/Phoenix Plugin for Claude Code                           │\n│                                                                     │\n│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐           │\n│  │    20    │    40    │    96    │    18    │    22    │           │\n│  │  Agents  │  Skills  │   Refs   │  Hooks   │Iron Laws │           │\n│  └──────────┴──────────┴──────────┴──────────┴──────────┘           │\n│                                                                     │\n│  AGENTS                          COMMANDS                           │\n│  ─────────────────────           ──────────────────────────         │\n│  Orchestrators (opus)            Workflow                           │\n│    workflow-orchestrator           /phx:plan    /phx:work           │\n│    planning-orchestrator           /phx:review  /phx:full           │\n│    parallel-reviewer               /phx:compound /phx:quick         │\n│    context-supervisor              /phx:brief   /phx:triage         │\n│                                                                     │\n│  Reviewers (sonnet)              Investigation \u0026 Debug              │\n│    elixir-reviewer                 /phx:investigate /phx:trace      │\n│    testing-reviewer                /ecto:n1-check   /phx:perf       │\n│    security-analyzer               /ecto:constraint-debug           │\n│    iron-law-judge                  /lv:assigns                      │\n│                                                                     │\n│  Architecture (sonnet)           Analysis \u0026 Review                  │\n│    liveview-architect              /phx:audit    /phx:verify        │\n│    ecto-schema-designer            /phx:techdebt /phx:boundaries    │\n│    phoenix-patterns-analyst        /phx:pr-review /phx:challenge    │\n│    otp-advisor                     /phx:research  /phx:document     │\n│                                                                     │\n│  Investigation (sonnet/haiku)    Knowledge (auto-loaded)            │\n│    deep-bug-investigator           liveview-patterns  ecto-patterns │\n│    call-tracer                     elixir-idioms      security      │\n│    xref-analyzer                   phoenix-contexts   oban          │\n│    verification-runner             testing   deploy   tidewave      │\n│                                                                     │\n│  Domain (sonnet)                 Hooks                              │\n│    oban-specialist                 auto-format · auto-compile       │\n│    deployment-validator            iron-law-verify · security-scan  │\n│    hex-library-researcher          debug-stmt-detect · error-critic │\n│    web-researcher                  progress-tracking · block-danger │\n│                                                                     │\n│  ───────────────────────────────────────────────────────────        │\n│  22 Iron Laws · Tidewave MCP · plan→work→verify→review→compound     │\n│  github.com/oliver-kriska/claude-elixir-phoenix                     │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n\u003e **v2.8.0** -- 41 skills, 20 agents, 8-dimension quality eval, autoresearch self-improvement loop. Feedback welcome via [issues](https://github.com/oliver-kriska/claude-elixir-phoenix/issues).\n\n## Installation\n\n### From GitHub (recommended)\n\n```bash\n# In Claude Code, add the marketplace\n/plugin marketplace add oliver-kriska/claude-elixir-phoenix\n\n# Install the plugin\n/plugin install elixir-phoenix\n```\n\n### From Local Path (for development)\n\n```bash\ngit clone https://github.com/oliver-kriska/claude-elixir-phoenix.git\n\n# Option A: Add as local marketplace\n/plugin marketplace add ./claude-elixir-phoenix\n/plugin install elixir-phoenix\n\n# Option B: Test plugin directly\nclaude --plugin-dir ./claude-elixir-phoenix/plugins/elixir-phoenix\n```\n\n## Getting Started\n\nNew to the plugin? Run the interactive tutorial:\n\n```bash\n/phx:intro\n```\n\nIt walks through the workflow, commands, and features in 6 short sections (~5 min).\nSkip to any section with `/phx:intro --section N`.\n\n## Quick Examples\n\n```bash\n# Just describe what you need — the plugin detects complexity and suggests the right approach\n\u003e Fix the N+1 query in the user dashboard\n\n# Plan a feature with parallel research agents, then execute\n/phx:plan Add email notifications for new comments\n/phx:work .claude/plans/email-notifications/plan.md\n\n# Full autonomous mode — plan, implement, review, capture learnings\n/phx:full Add user profile avatars with S3 upload\n\n# 4-agent parallel code review (idioms, security, tests, compilation)\n/phx:review\n\n# Quick implementation — skip ceremony, just code\n/phx:quick Add pagination to the users list\n\n# Structured bug investigation with 4 parallel tracks\n/phx:investigate Timeout errors in the checkout LiveView\n\n# Project health audit across 5 categories\n/phx:audit\n```\n\nThe plugin auto-loads domain knowledge based on what files you're editing\n(LiveView patterns for `*_live.ex`, Ecto patterns for schemas, security rules for auth code)\nand enforces [Iron Laws](#iron-laws-non-negotiable-rules) that prevent common Elixir/Phoenix mistakes.\n\n## How It Works\n\n### The Lifecycle\n\nThe plugin implements a **Brainstorm, Plan, Work, Verify, Review, Compound** lifecycle. Each phase produces artifacts in a namespaced directory:\n\n```\n/phx:brainstorm → /phx:plan → /phx:work → /phx:verify → /phx:review → /phx:compound\n       │               │           │            │              │              │\n       ↓               ↓           ↓            ↓              ↓              ↓\n  interview.md    plans/{slug}/  (in namespace) (in namespace) (in namespace) solutions/\n```\n\n- **Plan** -- Research agents analyze your codebase in parallel, then synthesize a structured implementation plan\n- **Work** -- Execute the plan task-by-task with quick compile checks after each change\n- **Verify** -- Full verification loop (compile, format, credo, test) before review\n- **Review** -- Four specialist agents audit your code in parallel (idioms, security, tests, static analysis)\n- **Compound** -- Capture what you learned as reusable knowledge for future sessions\n\n### Key Concepts\n\n- **Filesystem is the state machine.** Each phase reads from the previous phase's output. No hidden state.\n- **Plan namespaces.** Each plan owns all its artifacts in `.claude/plans/{slug}/` -- plan, research, reviews, progress, scratchpad.\n- **Plan checkboxes track progress.** `[x]` = done, `[ ]` = pending. `/phx:work` finds the first unchecked task and continues.\n- **One plan = one work unit.** Large features get split into multiple plans. Each is self-contained.\n- **Agents are automatic.** The plugin spawns specialist agents behind the scenes. You don't manage them directly.\n\n### Plan Namespaces\n\nEvery plan gets its own directory with all related artifacts:\n\n```\n.claude/\n├── plans/{slug}/          # Everything for ONE plan\n│   ├── plan.md            # The plan itself (checkboxes = state)\n│   ├── research/          # Research agent output\n│   ├── reviews/           # Review findings (individual tracks)\n│   ├── summaries/         # Compressed multi-agent output\n│   ├── progress.md        # Session progress log\n│   └── scratchpad.md      # Auto-written decisions, dead-ends, handoffs\n├── reviews/               # Ad-hoc reviews (no plan context)\n└── solutions/             # Compound knowledge (reusable across plans)\n```\n\nNo more scattered files across `.claude/planning/`, `.claude/progress/`, `.claude/reviews/`. One plan, one directory, everything together.\n\n## Architecture\n\n### Agent Hierarchy\n\nThe plugin uses 20 agents organized into 3 tiers:\n\n```\n                    ┌──────────────────────────────┐\n                    │  Orchestrators (opus model)  │\n                    │  Coordinate phases, spawn    │\n                    │  specialists, manage flow    │\n                    └──────────┬───────────────────┘\n                               │\n        ┌──────────────────────┼──────────────────────┐\n        │                      │                      │\n        ▼                      ▼                      ▼\n┌───────────────┐  ┌───────────────────┐  ┌────────────────────┐\n│ workflow-     │  │ planning-         │  │ parallel-          │\n│ orchestrator  │  │ orchestrator      │  │ reviewer           │\n│ (full cycle)  │  │ (research phase)  │  │ (review phase)     │\n└───────────────┘  └───────────────────┘  └────────────────────┘\n                               │                      │\n                    ┌──────────┼──────────┐    ┌──────┼──────┐\n                    ▼          ▼          ▼    ▼      ▼      ▼\n             ┌──────────┐ ┌────────┐ ┌──────┐ ... 4 specialist\n             │ liveview │ │ ecto   │ │ web  │     review agents\n             │ architect│ │ schema │ │ rsch │\n             └──────────┘ └────────┘ └──────┘\n                               │\n                    ┌──────────┴──────────┐\n                    ▼                     ▼\n             ┌────────────┐      ┌──────────────┐\n             │  context-  │      │ Orchestrator  │\n             │ supervisor │ ───► │ reads ONLY    │\n             │  (haiku)   │      │ the summary   │\n             └────────────┘      └──────────────┘\n```\n\n**Orchestrators** (opus) -- Primary workflow coordinators, security-critical analysis.\n**Specialists** (sonnet) -- Domain experts, secondary orchestrators, judgment-heavy tasks. Sonnet 4.6 achieves near-opus quality at sonnet pricing.\n**Lightweight** (haiku) -- Mechanical tasks: verification, compression, dependency analysis.\n\n### The Context Supervisor Pattern\n\nWhen an orchestrator spawns 4-8 research agents, their combined output can exceed 50k tokens -- flooding the parent's context window. The **context-supervisor** solves this using an OTP-inspired pattern:\n\n```\n┌────────────────────────────────────────────────────┐\n│  Orchestrator (thin coordinator, ~10k context)     │\n│  Only reads: summaries/consolidated.md             │\n└──────────────────┬─────────────────────────────────┘\n                   │ spawns AFTER workers finish\n┌──────────────────▼─────────────────────────────────┐\n│  context-supervisor (haiku, fresh 200k context)    │\n│  Reads: all worker output files                    │\n│  Applies: compression strategy based on size       │\n│  Validates: every input file represented           │\n│  Writes: summaries/consolidated.md                 │\n└──────────────────┬─────────────────────────────────┘\n                   │ reads from\n     ┌─────────────┼─────────────┐\n     ▼             ▼             ▼\n  worker 1      worker 2      worker N\n  research/     research/     research/\n  patterns.md   security.md   liveview.md\n```\n\n**How compression works:**\n\n| Total Output    | Strategy   | Compression | What's Kept                    |\n| --------------- | ---------- | ----------- | ------------------------------ |\n| Under 8k tokens | Index      | ~100%       | Full content with file list    |\n| 8k - 30k tokens | Compress   | ~40%        | Key findings, decisions, risks |\n| Over 30k tokens | Aggressive | ~20%        | Only critical items            |\n\nThe supervisor also **deduplicates** -- if two agents flag the same issue\n(e.g., both the security analyzer and code reviewer find a missing\nauthorization check), it merges them into one finding with both sources cited.\n\n**Used by:** planning-orchestrator (research synthesis), parallel-reviewer (review deduplication), audit skill (cross-category analysis).\n\n### How Planning Works\n\nWhen you run `/phx:plan Add real-time notifications`:\n\n```\n1. planning-orchestrator analyzes your request\n   │\n2. Spawns specialists IN PARALLEL based on feature needs:\n   ├── phoenix-patterns-analyst  (always -- scans your codebase)\n   ├── liveview-architect        (if UI/real-time feature)\n   ├── ecto-schema-designer      (if database changes needed)\n   ├── security-analyzer         (if auth/user data involved)\n   ├── oban-specialist           (if background jobs needed)\n   ├── web-researcher            (if unfamiliar technology)\n   └── ... up to 8 agents\n   │\n3. Each agent writes to plans/{slug}/research/{topic}.md\n   │\n4. context-supervisor compresses all research into one summary\n   │\n5. Orchestrator reads the summary + synthesizes the plan\n   │\n6. Output: plans/{slug}/plan.md with [P1-T1] checkboxes\n```\n\n### How Review Works\n\nWhen you run `/phx:review`:\n\n```\n1. parallel-reviewer collects your git diff\n   │\n2. Delegates to 4 EXISTING specialist agents:\n   ├── elixir-reviewer      → Idioms, patterns, error handling\n   ├── security-analyzer    → SQL injection, XSS, auth gaps\n   ├── testing-reviewer     → Test coverage, factory patterns\n   └── verification-runner  → mix compile, format, credo, test\n   │\n3. Each writes to plans/{slug}/reviews/{track}.md\n   │\n4. context-supervisor deduplicates + consolidates\n   │\n5. Output: plans/{slug}/summaries/review-consolidated.md\n```\n\n## Usage Guide\n\n### Quick tasks (bug fixes, small changes)\n\nJust describe what you need. The plugin auto-detects complexity and suggests the right approach:\n\n```\n\u003e Fix the N+1 query in the dashboard\n\nClaude: This is a simple fix (score: 2). I'll handle it directly.\n```\n\nOr use `/phx:quick` to skip ceremony:\n\n```\n/phx:quick Add pagination to the users list\n```\n\n### Medium tasks (new features, refactors)\n\nUse `/phx:plan` to create an implementation plan, then `/phx:work` to execute it:\n\n```\n/phx:plan Add email notifications for new comments\n```\n\nThe plugin will:\n\n1. Spawn research agents to analyze your codebase patterns\n2. Show a completeness check (every requirement mapped to a task)\n3. Ask you how to proceed (start implementation, review plan, adjust)\n\nWhen starting implementation, the plugin recommends a **fresh session** for plans with 5+ tasks. The plan file is self-contained, so no context from the planning session is needed:\n\n```\n# In a new Claude Code session:\n/phx:work .claude/plans/email-notifications/plan.md\n```\n\n### Large tasks (new domains, security features)\n\nUse deep research planning:\n\n```\n/phx:plan Add OAuth login with Google and GitHub --depth deep\n```\n\nThis spawns 4+ parallel research agents, then produces a detailed plan.\nFor security-sensitive features, the plugin will ask clarifying questions\nbefore proceeding. Or use `/phx:full` for fully autonomous development.\n\n### Fixing review issues\n\nAfter implementing, run a review:\n\n```\n/phx:review\n```\n\nFour parallel agents check your code (idioms, tests, security, compilation). If blockers are found, the plugin asks whether to replan or fix directly:\n\n```\nReview found 2 blockers:\n1. Missing authorization in handle_event -- security risk\n2. N+1 query in list_comments -- performance issue\n\nOptions:\n- Replan fixes (/phx:plan --existing)\n- Fix directly (/phx:work)\n- Handle myself\n```\n\n### Project health checks\n\nRun a comprehensive audit with 5 parallel specialist agents:\n\n```\n/phx:audit                    # Full audit\n/phx:audit --quick            # 2-3 minute pulse check\n/phx:audit --focus=security   # Deep dive single area\n/phx:audit --since HEAD~10    # Audit recent changes only\n```\n\nThe audit scores your project across 5 categories (architecture, performance, security, tests, dependencies) and produces an actionable report.\n\n### Full autonomous mode\n\nFor hands-off development:\n\n```\n/phx:full Add user profile avatars with S3 upload\n```\n\nRuns the complete cycle: plan (with research), work, verify, review. After review fixes, re-verifies before cycling back. Captures learnings on completion.\n\n## Workflow Tips\n\n### Context management\n\n- `/phx:plan` creates a **self-contained plan file** with all implementation details\n- For 5+ task plans, start `/phx:work` in a **fresh session** to maximize context space\n- For small plans (2-4 tasks), continuing in the same session is fine\n\n### Resuming work\n\nPlan checkboxes are the state. If a session ends mid-work:\n\n```\n# Just run /phx:work on the same plan -- it finds the first [ ] and continues\n/phx:work .claude/plans/my-feature/plan.md\n```\n\n### Splitting large features\n\nWhen a feature has 10+ tasks across different domains, the plugin offers to split into multiple plan files:\n\n```\nCreated 3 plans (14 total tasks):\n1. .claude/plans/auth/plan.md (5 tasks -- login, register, reset)\n2. .claude/plans/profiles/plan.md (4 tasks -- avatar, bio, settings)\n3. .claude/plans/admin/plan.md (5 tasks -- dashboard, roles)\n\nRecommended order: 1 -\u003e 2 -\u003e 3\n```\n\nExecute each plan separately with `/phx:work`.\n\n### Learning from mistakes\n\nAfter fixing a bug or receiving a correction:\n\n```\n/phx:learn-from-fix Fixed N+1 query -- always preload associations in context functions\n```\n\nThis updates the plugin's `common-mistakes.md` knowledge base so the same mistake is prevented in future sessions.\n\n## Iron Laws (Non-Negotiable Rules)\n\nThe plugin enforces critical rules and **stops with an explanation** if code would violate them:\n\n**LiveView:** No database queries in disconnected mount. Use streams for lists \u003e100 items. Check `connected?/1` before PubSub subscribe.\n\n**Ecto:** Never use `:float` for money. Always pin values with `^` in queries. Separate queries for `has_many`, JOIN for `belongs_to`.\n\n**Oban:** Jobs must be idempotent. Args use string keys. Never store structs in args.\n\n**Security:** No `String.to_atom` with user input. Authorize in every LiveView `handle_event`. Never use `raw/1` with untrusted content.\n\n**OTP:** No process without a runtime reason. Supervise all long-lived processes.\n\n**Elixir:** Declare `@external_resource` for compile-time files. Wrap third-party library APIs behind project-owned modules. Never use `assign_new` for values refreshed every mount.\n\n## Commands Reference\n\n### Workflow\n\n| Command                 | Description                                                  |\n| ----------------------- | ------------------------------------------------------------ |\n| `/phx:full \u003cfeature\u003e`   | Full autonomous cycle (plan, work, verify, review, compound) |\n| `/phx:brainstorm \u003ctopic\u003e` | Adaptive requirements gathering before planning            |\n| `/phx:plan \u003cinput\u003e`     | Create implementation plan with specialist agents            |\n| `/phx:plan --existing`  | Enhance existing plan with deeper research                   |\n| `/phx:work \u003cplan-file\u003e` | Execute plan tasks with verification                         |\n| `/phx:review [focus]`   | Multi-agent code review (4 parallel agents)                  |\n| `/phx:compound`         | Capture solved problem as reusable knowledge                 |\n| `/phx:triage`           | Interactive triage of review findings                        |\n| `/phx:document`         | Generate @moduledoc, @doc, README, ADRs                      |\n| `/phx:learn-from-fix \u003clesson\u003e`   | Capture lessons learned                                      |\n| `/phx:brief \u003cplan\u003e`     | Interactive plan walkthrough                                 |\n| `/phx:perf`             | Performance analysis with specialist agents                  |\n| `/phx:pr-review`        | Address PR review comments                                   |\n\n### Utility\n\n| Command                  | Description                                                |\n| ------------------------ | ---------------------------------------------------------- |\n| `/phx:intro`             | Interactive plugin tutorial (6 sections, ~5 min)           |\n| `/phx:init`              | Initialize plugin in a project (auto-activation rules)     |\n| `/phx:help`              | Interactive command advisor — recommends the right command |\n| `/phx:quick \u003ctask\u003e`      | Fast implementation, skip ceremony                         |\n| `/phx:investigate \u003cbug\u003e` | Systematic bug debugging (4 parallel investigation tracks) |\n| `/phx:research \u003ctopic\u003e`  | Research Elixir topics on the web                          |\n| `/phx:verify`            | Run full verification (compile, format, credo, test)       |\n| `/phx:permissions`       | Scan sessions, recommend safe Bash permissions             |\n| `/phx:trace \u003cfunction\u003e`  | Build call trees to trace function flow                    |\n| `/phx:boundaries`        | Analyze Phoenix context boundaries with mix xref           |\n| `/phx:examples`          | Practical examples and pattern walkthroughs                |\n| `/ecto:constraint-debug` | Debug Ecto constraint violations                           |\n\n### Analysis\n\n| Command              | Description                                       |\n| -------------------- | ------------------------------------------------- |\n| `/ecto:n1-check`     | Detect N+1 query patterns                         |\n| `/lv:assigns \u003cfile\u003e` | Audit LiveView assigns for memory issues          |\n| `/phx:techdebt`      | Find technical debt and refactoring opportunities |\n| `/phx:audit`         | Full project health audit with 5 parallel agents  |\n| `/phx:challenge`     | Rigorous review mode (\"grill me\")                 |\n\n## Agents (20)\n\n| Agent                        | Model  | Memory  | Role                                         |\n| ---------------------------- | ------ | ------- | -------------------------------------------- |\n| **workflow-orchestrator**    | opus   | project | Full cycle coordination (plan, work, review) |\n| **planning-orchestrator**    | opus   | project | Parallel research agent coordination         |\n| **parallel-reviewer**        | opus   | --      | 4-agent parallel code review                 |\n| **deep-bug-investigator**    | sonnet | --      | 4-track parallel bug investigation           |\n| **call-tracer**              | sonnet | --      | Parallel call tree tracing                   |\n| **security-analyzer**        | opus   | --      | OWASP vulnerability scanning                 |\n| **context-supervisor**       | haiku  | --      | Multi-agent output compression               |\n| **verification-runner**      | haiku  | --      | mix compile, format, credo, test             |\n| **iron-law-judge**           | sonnet | --      | Pattern-based Iron Law detection             |\n| **xref-analyzer**            | haiku  | --      | Module dependency analysis                   |\n| **hex-library-researcher**   | sonnet | --      | Hex.pm library evaluation                    |\n| **liveview-architect**       | sonnet | --      | Component structure, streams, async patterns |\n| **ecto-schema-designer**     | sonnet | --      | Migrations, data models, query patterns      |\n| **phoenix-patterns-analyst** | sonnet | project | Codebase pattern discovery                   |\n| **elixir-reviewer**          | sonnet | --      | Code idioms, patterns, conventions           |\n| **testing-reviewer**         | sonnet | --      | ExUnit, Mox, LiveView test patterns          |\n| **oban-specialist**          | sonnet | --      | Worker idempotency, error handling           |\n| **otp-advisor**              | sonnet | --      | GenServer, Supervisor, process design        |\n| **deployment-validator**     | sonnet | --      | Docker, Kubernetes, Fly.io config            |\n| **web-researcher**           | sonnet | --      | ElixirForum, HexDocs, GitHub research        |\n\nAgents with `project` memory build up knowledge across sessions\nin `.claude/agent-memory/\u003cagent-name\u003e/`. Orchestrators remember\narchitectural decisions; pattern analysts skip redundant discovery.\n\n## Reference Skills (Auto-Loaded)\n\nThese load automatically based on file context -- no commands needed:\n\n| Skill                  | Triggers On                                 |\n| ---------------------- | ------------------------------------------- |\n| `elixir-idioms`        | OTP/BEAM code, GenServer, Supervisor, Task  |\n| `phoenix-contexts`     | Context modules, router, plugs, controllers |\n| `liveview-patterns`    | `*_live.ex`, mount, handle_event, streams   |\n| `ecto-patterns`        | Schemas, migrations, Repo calls, changesets |\n| `testing`              | `*_test.exs`, factories, test support       |\n| `oban`                 | Oban workers, perform/1, queue config       |\n| `security`             | Auth, sessions, CSRF/CSP, input validation  |\n| `deploy`               | Dockerfile, fly.toml, runtime.exs, releases |\n| `tidewave-integration` | Runtime debugging, live process inspection  |\n| `intent-detection`     | First message routing to /phx: commands     |\n| `compound-docs`        | Solution documentation lookups              |\n\n## Tidewave MCP Integration\n\nWhen your Phoenix app runs with [Tidewave](https://github.com/tidewave-elixir/tidewave), the plugin automatically detects it and uses runtime tools:\n\n```elixir\n# Add to mix.exs\n{:tidewave, \"~\u003e 0.1\", only: :dev}\n\n# Add to endpoint.ex (in dev block)\nplug Tidewave\n```\n\nAvailable runtime tools: execute Elixir code, run SQL queries, get docs for your exact dependency versions, introspect Ecto schemas, read application logs.\n\n## Requirements\n\n- Claude Code CLI\n- Elixir/Phoenix project\n\n### Optional\n\n- **Tidewave** for runtime debugging\n- **[ccrider](https://github.com/neilberkman/ccrider)** for session analysis (see Contributing)\n- **Ralph Wiggum Loop** for autonomous iteration across context resets\n\n## Contributing\n\nPRs welcome! See [CLAUDE.md](CLAUDE.md) for full conventions.\n\n### Quality Gate\n\nEvery PR must pass the CI quality gate (lint + test + eval). Run locally before pushing:\n\n```bash\nmake help             # Show all available commands\nmake eval             # Quick: lint + score changed skills/agents only\nmake eval-all         # Full structural: all 41 skills + all 20 agents\nmake eval-fix         # Auto-fix lint + show failures + suggest autoresearch\nmake test             # 52 pytest tests for eval framework\nmake ci               # Full CI: lint + test + eval (same as GitHub Actions)\n```\n\nThe eval framework scores skills across **8 dimensions** and agents across **5 dimensions**.\nSkills must score \u003e= 0.95 to pass. Run `make eval-all` for details.\n\n### Development Rules\n\n- **Skills**: ~100 lines SKILL.md + `references/` for details. Must include Iron Laws, \"Use when...\" in description.\n- **Agents**: under 300 lines, `disallowedTools: Write, Edit, NotebookEdit` for reviewers, `permissionMode: bypassPermissions` always.\n- **All markdown** passes `npm run lint`\n- **New skills/agents** must pass `npm run eval` before merging\n- **Autoresearch**: Run `npm run eval:fix` to auto-detect and fix quality issues\n\n### Autoresearch (Self-Improvement Loop)\n\nThe plugin includes an internal eval framework (`lab/eval/`) that scores all skills and agents. When quality drops, the autoresearch loop can fix it:\n\n```bash\n# Score everything, show failures, get auto-fix command\nnpm run eval:fix\n\n# Or run the autoresearch loop directly (targets weakest skill, fixes one issue per iteration)\nclaude -p 'Run autoresearch...' --allowedTools 'Edit,Read,Write,Bash,Glob,Grep'\n```\n\nThe eval framework uses 24 deterministic Python matchers + haiku-based behavioral trigger testing. See `lab/eval/` for details.\n\n### Analyze your sessions to improve the plugin\n\nThe plugin includes session analysis tools that help identify improvement opportunities.\nIf you use this plugin (or work on Elixir/Phoenix projects with Claude Code),\nyou can analyze your own sessions to find patterns that the plugin should handle better.\n\n**Setup:**\n\n1. Clone this repo: `git clone https://github.com/oliver-kriska/claude-elixir-phoenix.git`\n2. Install [ccrider MCP](https://github.com/neilberkman/ccrider): `claude mcp add ccrider -- npx @neilberkman/ccrider`\n\n**Available tools** (dev-only, not shipped with the plugin):\n\n```bash\n# Tier 1: Discover sessions and compute deterministic metrics\n/session-scan\n/session-scan --project myapp\n\n# Tier 2: Qualitative analysis of high-signal sessions\n/session-deep-dive\n/session-deep-dive --date 2026-03-01\n\n# Trends: Windowed aggregates (7d/30d/all) from metrics ledger\n/session-trends\n/session-trends --compare baseline\n\n# Skill effectiveness monitoring (requires session-scan data)\n/skill-monitor                  # Dashboard: all skills\n/skill-monitor --improve        # Generate improvement recommendations\n```\n\n### What session analysis finds\n\n- **Friction points** -- where you got stuck, repeated commands, abandoned approaches\n- **Workflow patterns** -- how you work (planning vs diving in, tool usage)\n- **Plugin improvement opportunities** -- missing automation, skills, or Iron Laws\n\nEach analysis report includes a **Plugin Improvement Opportunities** section that identifies:\n\n- Manual workflows that could be automated by a new skill or hook\n- Code patterns that caused bugs but the plugin doesn't catch (Iron Law candidates)\n- Missing skills or agents for common tasks\n- Auto-loading gaps where skills should trigger but don't\n\nShare these findings in issues or PRs to help make the plugin better for everyone.\n\n## Roadmap\n\n- **elixir-inspector** (in progress) -- Separate plugin for 6-layer codebase analysis.\n  Generates Credo checks, skills, CI steps, and review prompts from your project patterns.\n  See the [open PR](https://github.com/oliver-kriska/claude-elixir-phoenix/pulls).\n- **Tier 2/3 behavioral eval** -- Instruction-following tests and full A/B skill comparison (with-skill vs without-skill outcome quality).\n- **Runtime eval integration** -- Connect session metrics to the eval framework for measuring real-world skill effectiveness.\n\n## Sources and Inspiration\n\nThis plugin was built with insights from these articles, repositories, and tools:\n\n### Repositories and Tools\n\n- \u003chttps://github.com/tidewave-elixir/tidewave\u003e\n- \u003chttps://github.com/neilberkman/ccrider\u003e\n- \u003chttps://github.com/nicobailon/visual-explainer\u003e\n- \u003chttps://github.com/VoltAgent/awesome-claude-code-subagents\u003e\n- \u003chttps://github.com/shanraisshan/claude-code-best-practice\u003e\n- \u003chttps://github.com/anthropics/claude-code\u003e\n- \u003chttps://github.com/anthropics/claude-plugins-official\u003e\n- \u003chttps://github.com/anthropics/skills\u003e\n- \u003chttps://github.com/rjs/shaping-skills\u003e\n- \u003chttps://github.com/affaan-m/everything-claude-code\u003e\n- \u003chttps://github.com/blader/theorist\u003e\n- \u003chttps://github.com/tmchow/tmc-marketplace\u003e (iterative-engineering plugin)\n- \u003chttps://github.com/SamJHudson01/Carmack-Council\u003e (persona-grounded expert council review)\n- \u003chttps://github.com/obra/superpowers\u003e (verification discipline, CSO patterns)\n- \u003chttps://github.com/boshu2/agentops\u003e\n\n### Articles\n\n- \u003chttps://www.codecon.sk/search-is-not-magic-with-postgresql\u003e\n- \u003chttps://peterullrich.com/complete-guide-to-full-text-search-with-postgres-and-ecto\u003e\n- \u003chttps://peterullrich.com/efficient-name-search-with-postgres-and-ecto\u003e\n- \u003chttps://elixirmerge.com/p/exploring-postgresql-search-techniques-with-elixir-and-ecto\u003e\n- \u003chttps://tidewave.ai/blog/the-future-of-coding-agents-is-vertical-integration\u003e\n- \u003chttps://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents\u003e\n- \u003chttps://openai.com/index/harness-engineering/\u003e\n- \u003chttps://www.ignorance.ai/p/the-emerging-harness-engineering\u003e\n- \u003chttps://martinfowler.com/articles/exploring-gen-ai/harness-engineering.html\u003e\n- \u003chttps://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents\u003e\n- \u003chttps://boristane.com/blog/how-i-use-claude-code/\u003e\n- \u003chttps://mitchellh.com/writing/my-ai-adoption-journey\u003e\n- \u003chttps://www.thepragmaticcto.com/p/no-vibes-allowed-context-engineering\u003e\n- \u003chttps://basecamp.com/shapeup\u003e\n- \u003chttps://pragprog.com/titles/jwpaieng/common-sense-guide-to-ai-engineering/\u003e\n- \u003chttps://allanmacgregor.com/posts/setting-up-tidewave-beam-introspection\u003e\n- \u003chttps://theengineeringmanager.substack.com/p/councils-of-agents\u003e\n- \u003chttps://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling\u003e\n- \u003chttps://arxiv.org/abs/2603.03329\u003e (AutoHarness: improving LLM agents by automatically synthesizing a code harness)\n- \u003chttps://x.com/heynavtoor\u003e\n\n## License\n\nMIT\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Foliver-kriska%2Fclaude-elixir-phoenix","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Foliver-kriska%2Fclaude-elixir-phoenix","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Foliver-kriska%2Fclaude-elixir-phoenix/lists"}