Intent-Router skill
A skill that turns a vague request into a typed IntentSpec: it looks answers up in your repo and asks the one question only you can answer
- 74 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Reads the repository, documents and, where connected, tickets to look answers up itself
- Writes spec files into the `.intent/` folder of the working directory
Install
- Works in
Manual install
npx skills add angel291592/Intent-RouterThe installer detects your agents and adds the skill to each. No keys or dependencies.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Reads the repository, documents and, where connected, tickets to look answers up itself
- Writes spec files into the `.intent/` folder of the working directory
This is third-party code. Review the repository files before installing.
What it does
Intent-Router is an «intent compiler» skill for AI agents. It takes a vague request such as «add caching to the user API» and, before any work starts, turns it into a structured IntentSpec contract. It works in three passes: parse the request, resolve the open questions, then typecheck and emit. In the second pass the skill looks for answers where they live: package.json, route code, git history, ADRs, and for customer support, order logs, tickets and the policy in force. It asks a question only when the sources hold no answer and the decision is yours. If a request contradicts itself, admits two readings or rests on a premise your repo already disproves, the skill says so, and if the request is still underspecified it refuses to emit a contract. Every run ends with a file `.intent/<intent>.intent.yaml`: probed fields carry evidence pointers, and the file records state from a pending question to finished work. A later session reads the file before probing anything: an answered question is not asked again and a settled contract is implemented as written. After the work, the skill checks the result against the spec one constraint at a time.
Who it is for. For developers and support leads who give agents short tasks and want one pointed question instead of guesses.
Good fit when
- A request like «add caching to the API» leaves both the backend and the cache failure policy open
- An agent guessed for you last time and shipped code that goes down with Redis
- You need a premise check: the repo already holds an ADR saying this approach was tried and reverted
- A decision should outlive the session: the spec is saved in `.intent/` and read by the next agent
- Support triage needs a refund-or-replace call grounded in the order, the plan and the policy
Not a fit when
- The request is already fully specified: the skill stays out of the way and adds nothing
- You are asking how something works rather than for work to be done
- The change is trivial and reversible, such as a typo
- You need an executed check: a `met` line in Verify points at a code line and the skill does not run tests
Example request
/intent-router add caching to the user APILimitations
The author ran the skill on OpenCode. For Claude Code, Codex, Cursor and about two dozen more agents compatibility is stated from their documentation and was not exercised in the repository.
Quality depends on the sources it can reach: with no repo, tickets or docs there is nowhere to probe and the skill asks more. Automatic firing is probabilistic, so for an important request start with an explicit `/intent-router`. Confidence in the backend-free mode is the model's self-report and should be read as ordinal. Eval figures come from a 17-case coding suite, support triage is measured by a single case, and the other domains are specified, not measured.
How to disable. Delete the `intent-router` folder from `.claude/skills/` or `.agents/skills/`, wherever you installed it, or from `~/` for a global install. The files in `.intent/` were created by the skill and you can remove them by hand.
FAQ
How do I install Intent-Router in Claude Code or Codex?
Run `npx skills add angel291592/Intent-Router`: the installer detects your agents and places the skill in each as `intent-router`. By hand, copy the `skills/intent-router/` folder into `.claude/skills/` for Claude Code or `.agents/skills/` for Codex, Cursor, OpenCode and others.
How is Intent-Router different from plan mode and grill-me?
Plan mode and grill-me converge on a decision through questions. In the author's comparison, Intent-Router also checks the request's premise against evidence, keeps a cross-session `.intent/*.yaml` artifact and checks the finished work against what was agreed. It also fires on its own when a request is underspecified.
What did the skill change in the code comparison?
In one caching task, all 3 runs with the skill asked a single question and wrote the cache failure policy into the code, while none of the 5 bare runs did. The sample is small, and the report is in evals/reports/.
What is the IntentSpec file and where does it live?
It is a YAML contract at `.intent/<intent>.intent.yaml` in the working folder. Probed fields carry evidence pointers, questions carry a status, and the result of checking the finished work is written at the end. The next agent reads it before probing and does not re-ask what was answered.
Does Intent-Router work without keys or services?
Yes, the base tier L0 is prompt-only: no dependencies, keys or paid services. Tiers with an OpenAI-compatible endpoint and calibrated Jev or Laya models are planned as optional.
Discussion
No questions or reviews yet.
Related
SkillsA CLI skill manager for AI agents: install from repositories, translate between agent formats and deploy into their configs
A skill that scores a prompt on five criteria, picks one of 31 frameworks and rewrites the request after clarifying questions
A parallel divergent ideation skill for agents: fans out under cognitive frames, prunes traps and deepens the best branches
Internet Court
Internet Court Skill
A skill for agent-to-agent deals: one entry point to identity, negotiation, contracts, payments, escrow and dispute resolution
A skill plus hooks that keep a coding agent on task and cut speculative defenses, unread checksums and scope creep
A skill registry with a CLI and API: the agent describes a task and gets a recommendation with a trust score and install command
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| Intent-Router (this entry) | no | 74 | |
| Spec Kit | no | 143,920 | a full spec-driven development process rather than one clarifying skill |
| Superpowers | no | 307,845 | a set of process skills covering clarification, plans, TDD and review |
README in short
The README states the problem: agents guess missing decisions, and a long interview tires the user. It then shows the four decision states (ROUTE, PROBE, ASK, HALT), two walkthroughs, one in a codebase and one in a support queue, and a comparison with plan mode, grill-me, spec-kit and Kiro across seven criteria. Separate sections cover the IntentSpec artifact, a table of domains marked «measured» or «specified», the evals and the honest limitations. The prior work the author builds on is listed at the end.
README badge
Original SKILL.md
---
name: intent-router
description: >-
Converges an underspecified request into a typed IntentSpec before planning or acting. Use when
the user asks to implement, add, change, refactor, fix, migrate, configure, handle, triage, sort
out, look into or decide something and the request leaves decisions open (which objects, which
approach, what happens on failure, which trade-off), contradicts itself, admits two readings, or
rests on an approach its sources may rule out — in a codebase, a ticket queue, a research brief
or a runbook — or when the user says "clarify the intent", "what do you need from me", or
invokes intent-router. Looks up what its sources hold (code, history, decision records, a ticket
log, an order record, the policy in force) before asking; asks only preference or irreversible
questions, one at a time, with a recommended default; halts instead of guessing; checks the
delivered work against the spec. Silent on a fully stated task its sources do not contradict.
Not for explaining existing state ("what does X do", "why is Y slow").
license: MIT
metadata:
version: "1.3.0"
author: angel291592
homepage: https://github.com/angel291592/Intent-Router
---
# Intent-Router
A compiler does not guess the address of an undefined symbol. Do not guess the user's intent.
This runs one layer *before* planning, routing or coding. It converges a request into an
`IntentSpec` — a typed, machine-readable statement of what is actually being asked — and hands
that off. It does not implement anything itself.
## 1. Purpose and when this fires
Three passes, in compiler order: **Parse** the request into a draft spec, **Resolve** every
open question by looking it up or asking, then **Typecheck and emit** — route, ask, or halt.
Start when **both** hold:
1. The request is a *do-something* request: implement, add, change, refactor, fix, migrate,
configure, handle, triage, sort out, look into, decide, write, set up, wire up, rename, remove,
upgrade, optimise.
2. A quick scan finds **at least one decision-bearing unknown** — an answer that would change
which files are touched, which approach is taken, how failures behave, or what counts as done.
Do not start when: the request asks you to explain existing state ("what does X do", "why is Y
slow") rather than to find something out and produce a deliverable; the silence check below passes
and its premise check finds no contradiction — every decision-bearing item is already stated, so
there is nothing to converge; or the request is trivially scoped and reversible (fix a typo).
**Look for a saved contract first.** Before probing, look for earlier work on this same request:
`<workspace>/.intent/<intent>.intent.yaml`, stem = the `intent` slug, matching on
`request`/`objects`. Its `verification_status` decides: