Elixir Skill Router

HARD-GATE

Non-negotiable: no implementation code until a test exists, runs, and fails for the right reason (feature missing, not config/syntax).
For all routing format requirements, see Output Style below.

Core Process

Triages and decomposes any Elixir/Phoenix request into ordered sub-tasks, then delegates to the correct specialized skill. Identify the matching skill from the catalog below and route to it using the format defined in Output Style.

Core Skills Catalog

The eight most-used skills are listed here. For the full catalog of all available skills, see directory.json at the repository root.

Skill Priority

Canonical priority rule — apply this whenever multiple skills could apply:

Priority: TDD → Planning → Implementation → Quality → Review.

State this rule immediately after the routing statement when more than one skill is involved.

Fallback for ambiguous requests: If no clear skill match, label this explicitly as Fallback: elixir-essentials for language ambiguity or Fallback: phoenix-liveview-essentials for web/Phoenix ambiguity.

Decomposition Examples

These examples show the routing statement format and skill-chain ordering. Apply the canonical priority rule from Skill Priority above when sequencing sub-tasks.

Example 1 — "I need to add user notifications to my Phoenix app. Users should receive an email when a job completes, and I want a live counter on the dashboard."

Sub-tasks in priority order (touches background jobs, email delivery, LiveView UI, and the data layer):

• skills/testing/testing-essentials — write failing tests for job completion callback and email dispatch first (TDD gate).
• skills/infrastructure/oban-essentials — implement the job and its on-completion hook.
• skills/fundamentals/elixir-essentials — implement the mailer module.
• skills/database/ecto-essentials — add the notifications schema and migration.
• skills/phoenix/phoenix-liveview-essentials — wire the live counter into the dashboard LiveView.
• skills/quality/code-quality — quality gate before PR.

Next skill: skills/testing/testing-essentials

This request spans jobs, email, data, and LiveView. Starting with failing tests for the job completion callback.

Priority: TDD → oban-essentials → elixir-essentials → ecto-essentials → phoenix-liveview-essentials → code-quality.

Example 2 — "Refactor a crashing GenServer and review authentication for security issues."

Sub-tasks: security-essentials (audit auth first) → testing-essentials (reproduce crash) → otp-essentials (fix GenServer) → code-quality (final pass).

Next skill: skills/security/security-essentials

Authentication touches security boundaries; audit that first before addressing the GenServer crash.

Priority: security-essentials → testing-essentials → otp-essentials → code-quality.

Common Skill Chains

Output Style

Routing statement (required on every response): The routing statement MUST be the first substantive line of every response, before any analysis or implementation.

For a single skill:

Next skill: skills/testing/testing-essentials

This is a feature request. I will start by writing a failing test.

When multiple skills apply, immediately follow the routing line with one concise priority/chain statement:

Next skill: skills/security/security-essentials

This pull request contains custom input validation, so we will perform a security review first followed by code quality review.

Priority: security-essentials > code-quality; Chain: security-essentials then code-quality.

Language: Generated artifacts and output MUST be in English unless explicitly requested otherwise.

When Not to Use

• Do not invoke this skill for simple, single-concern requests that clearly map to one skill (e.g., "write a test for this function" → use testing-essentials directly)
• Do not invoke this skill if the request is a direct question about Elixir syntax or Phoenix patterns — route to the specific skill instead
• Do not invoke this skill if you already know all the skills needed and just need implementation guidance — use the specific skill directly
• Do not route through this skill when the user explicitly names a target skill (e.g., "use the oban-essentials skill")

Use elixir-essentials alone if you only need Elixir language guidance without orchestration.

Use testing-essentials alone if the test approach is already decided and you just need to write the spec.