Skip to content
v0.3.1MIT

Skill that makes your coding agent stop and ask instead of silently resolving spec ambiguity, picking up workarounds, or shipping 'close enough'. Accuracy over autonomy.

Urd

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

Urd is one skill file. When the agent moves from a plan into code and the plan runs out, it makes the agent check the source of truth or ask you, with options and a recommendation.

What you install

In Claude Code:

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

Then run /reload-plugins or restart Claude Code. No config, no API key.

PieceWhere it landsWhat it doesWhen it acts
The Urd skill, one Markdown file (skills/urd/SKILL.md)your Claude Code pluginsTells the agent when to stop and ask, and how to ask.When the agent moves from a plan, a design doc or a spec into implementation.
  • Never touches: your repository, your git, the network. It installs no hook, no MCP server and no command.
  • Needs: an agent that reads skills.
  • Costs: none of its own. The skill file is about 900 words, read when the skill fires.
  • In the agent's context: the skill's description always; the body when it fires.

Other agents: GitHub Copilot CLI, Cursor, a plain skill folder

GitHub Copilot CLI:

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

Cursor:

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

Then Developer: Reload Window.

A plain skill folder: copy skills/urd/SKILL.md to ~/.claude/skills/urd/SKILL.md (user level) or .claude/skills/urd/SKILL.md (project level), ~/.cursor/skills/urd/SKILL.md for Cursor, or wherever your agent reads skills.

What changes on the first day

  • When the spec is silent on a case the agent hits, it stops and asks instead of picking something.
  • When the spec contradicts itself, it names both sides and asks.
  • Before it adds a fallback, an exception or a TODO the spec did not sanction, or weakens a test to make code pass, it asks.
  • Its question names the step, quotes the spec, says what does not fit, gives numbered options and its recommendation.
  • It labels what it believes but has not checked, and re-reads the source when you challenge a claim.

Start

  1. Install with the two commands above.

    You see: urd among your plugins after the reload.

  2. Hand the agent a plan and let it implement. For example, a plan step that says "On 5xx response, retry up to 3 times with exponential backoff."

    You see: when the agent hits a case the plan does not cover, such as a 429, it stops with a question like this one.

    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?

  3. Answer with a number.

    You see: the agent carries on with your choice. Well-written plans trigger few stops, and sparse plans trigger many.

What it does not do

  • It biases the agent toward asking; it is not a runtime guarantee that the agent always stops.
  • It does not fix a vague spec for you; it shows you the gaps.
  • It does not remove bugs.
  • It is the wrong tool if you want a fast pass with every deviation resolved silently.

Remove it

In Claude Code:

claude plugin uninstall urd@urd-marketplace
claude plugin marketplace remove urd-marketplace

On Copilot CLI, copilot plugin uninstall urd@urd-marketplace. On Cursor, delete the link in ~/.cursor/plugins/local/urd. A copied skill file is removed by deleting it. Urd leaves nothing in your repository.

Where it fits

Urd is an add-on of the family: it attaches to the agent, depends on no other family tool and keeps its own version. Inside a Jarl loop the jarl itself follows it.

Read more: The skill · Changelog · Report a problem

The Yggdrasil family

Jarl is the loop. Yggdrasil is the law. Grain is the survey. Those three are the core, and they ship under one version number: one set of tools built and tested against each other. Each of them works alone. Where a repository has a check, the check decides what lands in a Jarl loop: a fresh reviewer can only stop a change, never make a failing check pass, and its word is recorded as testimony. A Jarl loop in a repository with no check lands on testimony alone, and says so. Law that stays inside one component is raised freely by the agent working it. Law or decisions that reach a whole type of code are shared vocabulary: the agent proposes them and they run as advice at once, and the client — the one person the whole system answers to — admits them in one batch when the work closes. Only the client lowers or vetoes law. The core's shared machine contracts are registered on one page. The family is developed in the open in Althing: its releases, research and rulings.

Start at the step where it hurts.

Where it hurtsStart with
More issues than one agent can hold in its headJarl
The agent keeps breaking what was agreedYggdrasil
Nobody knows what was agreedGrain, which earns its keep the moment you are about to write law
CoreWhat it holds
JarlThe loop. Everything seen becomes an issue, each piece of work gets one worker in its own worktree, nothing closes without evidence and a review, and no code closes without a fresh reviewer's word. Rulings keep their history, and a ruling about a whole type of code goes to the client in one batch when the loop closes.
YggdrasilThe law. The architecture graph, the rules over it and the log of why, checked before the agent moves on and re-proved in CI without a key. A rule that reaches a whole type runs as advice until the client ratifies it.
GrainThe survey. Mines a repository's own code and history into a first graph — components, dependencies, and the rules the code already keeps, each with the count of places that break it today; Yggdrasil accepts it with one command. It measures and never blocks.

Three add-ons attach to the agent rather than to the graph; each works alone, depends on nothing in the family and keeps its own version.

Add-onStageWhat it makes the agent prove
Ratatoskrrequest → intentKeeps the agent talking to you in plain words, not code, so you can follow what it's doing.
Urd (this one)intent → codeWhen the spec is ambiguous, it consults the source of truth and asks, it doesn't guess.
Researchercode → measured resultPoint it at a metric and it runs experiments, hypotheses kept and discarded.

License

MIT. Made by Krzysztof Dudek.