Skip to content
Skills Library
Programming · Planning

intent-detection

/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.

Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Original author description

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.

How it works

  1. Routing Table
  2. Behavior
  3. Confidence Signals
  4. Complexity Signals
  5. Iron Laws
  6. Routing Logic Example
  7. Integration
Original SKILL.md headings · 105 lines, 693 words
SKILL.md preview
---
name: intent-detection
description: 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.
---

# Intent Detection — Workflow Routing

When user describes work WITHOUT specifying a `/skill:phx-*` command, analyze their intent and suggest the appropriate workflow BEFORE starting work.

**Hard guard — check FIRST**: if the message starts with any slash command
(`/skill:phx-*`, `/skill:ecto-*`, `/skill:lv-*`, or any other `/command`), this skill does not apply.
Follow the invoked command directly — no routing analysis, no suggestion, zero
output from this skill.

## Routing Table

| Signal | Detected Intent | Suggest |
|--------|----------------|---------|
| "bug", "error", "crash", "failing", "broken", stack trace | Bug investigation | `/skill:phx-investigate` |
| "brainstorm", "explore idea", "not sure what I need", "vague idea", "let's discuss", "how to approach" | Ideation/requirements | `/skill:phx-brainstorm` |
| "add", "implement", "build", "create" + multi-step | New feature | `/skill:phx-plan` |
| "review", "check", "audit" code | Code review | `/skill:phx-review` |
| "fix" + small/specific scope | Quick fix | handle directly or `/skill:phx-quick` |
| "refactor", "clean up", "improve" | Refactoring | `/skill:phx-plan` (needs scope) |
| "research", "how to", "what's the best" | Research | `/skill:phx-research` |
| "evaluate", "compare", "adopt", "library", "should we use" | Library evaluation | `/skill:phx-research --library` |
| "test", "spec", "coverage" | Testing | handle directly or `/skill:phx-plan` |
| Describes 1-2 file changes, < 50 lines | Small task | handle directly |
| "deploy", "release", "production" | Deployment | `/skill:phx-verify` then deploy |
| "performance", "slow", "N+1", "memory" | Performance | `/skill:phx-perf` |
| "PR review", "review comments", "address feedback", "respond to PR" | PR response | `/skill:phx-pr-review` |
| "that worked", "fixed it", "problem solved" | Knowledge capture | `/skill:phx-compound` |
| "enhance plan", "more detail", "deepen" | Plan enhancement | `/skill:phx-plan --existing` |
| "triage", "which findings", "prioritize fixes" | Finding triage | `/skill:phx-triage` |

## Behavior

1. Read user's first message
2. Match against routing table (use keyword + context signals, not exact match)
3. If match found with multi-step workflow: "This looks like [intent]. I'd suggest `[command]` — want me to run it, or should I just dive in?"
4. If trivial task (typo, single-line fix, config change): skip suggestion, just do it
5. If user already specified a `/skill:phx-*` command: follow it, don't re-suggest
6. **NEVER block the user** — suggestion only, not mandatory

## Confidence Signals

High confidence (suggest immediately):

- Stack trace or error message pasted → `/skill:phx-investigate`
- "Add [feature] with [multiple components]" → `/skill:phx-plan`
- "Review my changes" or "check this PR" → `/skill:phx-review`

Medium confidence (suggest with caveat):

- "Fix [thing]" — could be quick or complex, suggest based on scope description
- "Update [thing]" — could be small edit or refactor

Low confidence (just do it):

- Single file mentioned, clear change
- "Change X to Y"
- Configuration or dependency updates

## Complexity Signals

When a task matches a workflow command, check complexity before suggesting:

**Trivial signals** (suggest `/skill:phx-quick` or handle directly):

- Single file mentioned explicitly
- "exclude X from Y", "add X to config", "rename", "change X to Y"
- Problem + solution both stated ("X is wrong, change to Y")
- One-line fix described

**Complex signals** (suggest `/skill:phx-plan` or `/skill:phx-investigate`):

- 3+ modules or files mentioned
- "intermittent", "race condition", "sometimes", "random"
- Stack trace with 5+ frames
- "across", "all", "every" (scope indicators)

**Override rule**: If user invokes `/skill:phx-full` but task matches trivial signals:
"This looks like a quick fix. Want `/skill:phx-quick` instead, or stick with the full cycle?"

## Iron Laws

1. **NEVER block on suggestion** — If user starts explaining, just do the work
2. **One suggestion max** — Don't re-suggest if user ignores first suggestion
3. **Commands are shortcuts, not gates** — All work can be done without commands

## Routing Logic Example

```
if has_slash_command($ARGUMENTS) -> follow command directly
elif has_stack_trace(message) -> suggest /skill:phx-investigate
elif matches("add|build|implement", message) and multi_step -> suggest /skill:phx-plan
elif matches("fix", message) and small_scope -> handle directly or /skill:phx-quick
elif matches("review|audit", message) -> suggest /skill:phx-review
else -> handle directly (no suggestion)
```

## Integration

This skill is consulted at session start. It works alongside:

- SessionStart hook (shows plugin loaded message)
- CLAUDE.md routing instructions (passive reference)
- Individual workflow skills (activated by commands)

Versions

RepositoryScoreLicence
This page · oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
slbug/claude-ruby-grape-rails100MIT

Database snapshot: 13.11.2026 · package version a28df60f1ef5 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100review
    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.
  • 100phoenix
    Expert Phoenix assistance covering Elixir web development, LiveView real-time reactive UIs, Ecto queries, and Channels. Use when building high-concurrency real-time web applications with minimal JavaScript.
  • 100phx-examples
    Provide Phoenix, LiveView, Ecto, OTP, or Oban examples. Use when asked for sample code, a walkthrough, a proper…
  • 100phoenix
    Use when building an Elixir web app with Phoenix — contexts, Ecto schemas, changesets and migrations, LiveView, channels and PubSub, the generators, and the boundary between domain logic and the web layer. Covers the classic LiveView over-rendering and Ecto N+1 traps. NOT pure…
  • 95elixir
    Use this skill when building with Elixir — Phoenix framework, OTP, BEAM, LiveView, Ecto, supervision trees. This skill enforces: OTP design principles, Phoenix context boundaries, LiveView state management, Ecto schema conventions, supervision tree structure. Do NOT use for:…
  • 100phoenix
    Build and debug Phoenix web interfaces and HTTP endpoints. Use for LiveView lifecycle and data loading, components, forms, routes, controllers, Plug, channels, and PubSub. Use ecto for changesets, queries, and persistence behind those interfaces.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.