convez.ai
SkillAutomaçãoIntermediário
krzysztofdudek

Urd Skill

krzysztofdudek/UrdSkill

Faz seu agente perguntar em vez de adivinhar quando o spec acaba

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill que intercepta agentes de IA no momento em que saem da especificação e força pausa para consultar a fonte de verdade ou fazer perguntas, em vez de adivinhar. Reduz decisões silenciosas enterradas em diffs ao apresentar opções contextualizadas com recomendações fundamentadas.

Instalação

$npx convez-ai krzysztofdudek/UrdSkill

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 semana
Versão
v0.3.1
Issues abertas
0
Contribuidores
1

Casos de uso

  • Implementação de features com specs ambíguas ou incompletas
  • Desenvolvimento de retry logic e tratamento de edge cases
  • Code review automatizado com rastreamento de decisões não documentadas

Veredito

Skill elegante que resolve um problema real em agentes de código: decisões silenciosas que viram bugs. A abordagem de forçar clareza estruturada no ponto de incerteza tem mérito, especialmente para specs imprecisas, mas seu valor depende de quão bem o agente identifica esses pontos.

README

A tradução para o português deste README ainda está na fila.

Urd

Your AI agent hit a gap in the spec — so it guessed, and shipped. Urd makes it stop and ask instead.

The moment the agent moves from a plan into code and the plan runs out, Urd makes it consult the source of truth or ask you — instead of inventing an answer and burying the decision in the diff.

/plugin marketplace add krzysztofdudek/UrdSkill
/plugin install urd@urd-marketplace

Run both, then /reload-plugins to activate it in this session (or restart Claude Code). No config, no API key. The skill activates on its own the moment the agent moves from a plan, design doc, or spec into implementation.

MIT licensed · single markdown file · works with any agent that reads skills · part of the Yggdrasil family · full skill body


See it

Step 4 of the plan: implement the retry logic. The plan says, verbatim:

"On 5xx response, retry up to 3 times with exponential backoff."

Mid-implementation the agent hits a 429 (rate-limited) — not a 5xx, but retryable. The spec is silent on it. The default agent picks something and moves on. Urd makes it stop:

Question — retry logic, step 4. The plan covers 5xx, but I've hit 429 (rate-limited): not 5xx, yet retryable. The spec doesn't say how to treat it. Three options:

  1. Treat 429 like 5xx — retry with backoff.
  2. Honor the Retry-After header if present, otherwise back off.
  3. Leave 429 to the caller — don't retry it here.

I'd go with (2). Proceed?

Note what it did: it didn't resolve the ambiguity silently. Ten seconds on a decision now, instead of finding it in the diff an hour later. That's the whole skill — at the moment of doubt, ask, don't guess.


When it fires

The skill activates the moment the agent moves from a plan/spec into implementation. Once active, it pushes toward asking rather than guessing whenever:

  • the spec is silent on a case the agent hit
  • the spec contradicts itself
  • the agent is about to add a fallback, exception, or TODO the spec didn't sanction
  • a test would have to be weakened or skipped to make the code pass
  • a framework or type-system constraint is forcing a workaround
  • the agent catches itself thinking "this is probably fine" without certainty

Well-written plans trigger few stops. Sparse plans trigger many. That's the point.


How it asks

When Urd asks, it gives you enough to decide in seconds — never an open-ended "what should I do?":

It tells youExample
Where it is in the plan"Step 4, retry logic"
What the spec says, verbatim"On 5xx, retry 3× with backoff"
What it found that doesn't fit"hit a 429, not covered"
The options, with trade-offsthe numbered list above
Its recommendation"I'd go with (2)"

It also distinguishes verified from believed: it states as fact only what it has checked against the source. An unverified inference — a cause, a mechanism, how an API behaves — it labels as a guess or verifies before you rely on it. Challenge a claim and it re-reads the source and corrects itself, instead of defending an answer it never confirmed.


Install

Claude Code plugin (recommended)

Two slash commands. The first registers this repo as a marketplace; the second installs the plugin from it.

/plugin marketplace add krzysztofdudek/UrdSkill
/plugin install urd@urd-marketplace

Then run /reload-plugins to activate it in the current session (or restart Claude Code). No config, no API key.

To upgrade later, refresh the marketplace and reinstall:

/plugin marketplace update urd-marketplace
/plugin install urd@urd-marketplace

GitHub Copilot CLI plugin

The same repo is also a GitHub Copilot CLI marketplace. Register it, then install the plugin:

copilot plugin marketplace add krzysztofdudek/UrdSkill
copilot plugin install urd@urd-marketplace

To upgrade later: copilot plugin update urd. The same skill body powers both Claude Code and Copilot — nothing changes in how it behaves.

Codex CLI plugin

Codex reads the same skill. Register this repo as a marketplace, then install:

codex plugin marketplace add krzysztofdudek/UrdSkill
codex plugin install urd@urd-marketplace

To upgrade later: codex plugin marketplace upgrade urd-marketplace. Or drop the single file into ~/.agents/skills/urd/SKILL.md (user-level) or .agents/skills/urd/SKILL.md (project-level).

Cursor plugin

Cursor auto-discovers the skill from the plugin manifest at the repo root. Install it locally:

git clone https://github.com/krzysztofdudek/UrdSkill.git
ln -s "$(pwd)/UrdSkill" ~/.cursor/plugins/local/urd

Then reload Cursor (Developer: Reload Window). Or drop the single file into ~/.cursor/skills/urd/SKILL.md (user-level) or .cursor/skills/urd/SKILL.md (project-level).

Single-file drop-in (any agent)

The whole skill is one frontmatter-tagged markdown file: skills/urd/SKILL.md. Copy it into your agent's skill directory.

  • Claude Code, user-level: ~/.claude/skills/urd/SKILL.md
  • Claude Code, project-level: .claude/skills/urd/SKILL.md in your repo
  • Other agents: wherever your tool reads markdown skills

Nothing else in this repo affects behavior — all of it lives in that one file.


What it doesn't claim

Urd is a skill that biases the agent toward asking — not a runtime guarantee it will always stop. It does not eliminate bugs, and it does not fix a vague spec for you: it surfaces the gaps so you can. If what you want is a fast pass with deviations resolved silently, this is deliberately the wrong tool — it trades clarification rounds for fewer wrong outcomes delivered confidently.


FAQ

Only when the spec doesn't cover the case. The skill carries an explicit ask-vs-proceed table — if the spec answers the question, it proceeds; if it doesn't, it asks. Most well-written plans don't trigger many stops. Sparse plans do — and that's the signal you wanted.

No — it composes. It governs the attitude moving from spec to code, not the process. TDD still says write the test first; Urd says ask when the test you'd write isn't covered by the spec.

Then don't install it. It's deliberately the opposite of "ship something." A correct outcome after a few clarification rounds beats a wrong outcome delivered without questions — but if you want the fast pass, this is the wrong tool.

Urð is the Norn who keeps the well at the root of Yggdrasil — the source of truth consulted before acting. The skill plays the same role for your codebase: the plan is the source of truth, not the agent's judgment. It's part of the Yggdrasil family.


The Yggdrasil family

Four tools, one thesis: make an AI coding agent prove correctness, stage by stage — because "done" isn't done. Each is a checkpoint at a different point in the pipeline, where the agent has to show its work before it continues.

ToolStageWhat it makes the agent prove
Ratatoskrrequest → intentReads your request back in plain words so you see what it understood before it builds.
Urd (this one)intent → codeWhen the spec is ambiguous, it consults the source of truth and asks — it doesn't guess.
Yggdrasilcode → architectureEvery change satisfies the rules that govern it, checked before the agent moves on.
Researchercode → measured resultPoint it at a metric and it runs experiments — hypotheses kept and discarded.

License

MIT © Krzysztof Dudek


Ver o original no GitHub

Bom para

Relacionados