Agent skill

Evaluating Pegs

by lineofflight in lineofflight/frankfurter

A skill your agent uses when adding, evaluating, or removing an entry in db/seeds/pegs/, when the user mentions a pegged or fixed currency, or when an issue suggests we should "pin" or "lock" a…

MITAuto-check passed

Install Evaluating Pegs

skills CLI
$ npx skills add lineofflight/frankfurter --skill evaluating-pegs -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install lineofflight/frankfurter evaluating-pegs --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/lineofflight/frankfurter.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/evaluating-pegs .claude/skills/evaluating-pegs && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
evaluating-pegs
GitHub stars
2k
Token cost
~1.6k tokens
SKILL.md length
890 words
Files
1
Skills in repo
2
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when adding, evaluating, or removing an entry in db/seeds/pegs/, when the user mentions a pegged or fixed currency, or when an issue suggests we should "pin" or "lock" a…

  • Works in 4 steps: Officially asserted by an issuing… → Currently in force — not historical. If… → A specific rate is asserted, not a band,… → …
  • Removing an entry in db/seeds/pegs/
  • SKILL.md covers The Bar, What Does Not Qualify, Schema and Adding an Entry, plus 4 more sections
  • Reaches centralbank.ae

What it does

Evaluating Pegs is an agent skill from lineofflight/frankfurter. Use when adding, evaluating, or removing an entry in db/seeds/pegs/, when the user mentions a pegged or fixed currency, or when an issue suggests we should "pin" or "lock" a currency to another. Also use when deciding whether to filter or override provider rates based on an assumed peg.

Its SKILL.md is about 1.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It works with Ruby. The licence is MIT.

When your agent uses it

  • Removing an entry in db/seeds/pegs/
  • The user mentions a pegged
  • An issue suggests we should pin
  • Lock a currency to another

Example prompts

  • “/evaluating-pegs”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Officially asserted by an issuing authority (central bank, monetary authority, currency board, or government).
  2. Currently in force — not historical. If a peg ended, remove the entry; don't keep it with a sunset date.
  3. A specific rate is asserted, not a band, target, or "managed float."
  4. A primary source exists: the issuing authority's own page, a treaty, or legislation. Wikipedia is acceptable as a fallback for…

What it can do on your machine

Read from SKILL.md and the folder at commit 71334f7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • centralbank.ae

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Evaluating Pegs loads about 1.6k tokens when it runs. Until then it costs about 76 tokens; SKILL.md has 890 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~76
When it runs · the whole SKILL.md, loaded when a task matches
~1.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from lineofflight/frankfurter at commit 71334f7, republished under its MIT licence (© lineofflight). 890 words, ~1,600 tokens.

Download SKILL.mdSave it as .claude/skills/evaluating-pegs/SKILL.md (or your agent's skills folder).
name
evaluating-pegs
description
Use when adding, evaluating, or removing an entry in db/seeds/pegs/, when the user mentions a pegged or fixed currency, or when an issue suggests we should "pin" or "lock" a currency to another. Also use when deciding whether to filter or override provider rates based on an assumed peg.

Pegs Policy

The bar for entries in db/seeds/pegs/. These definitions directly affect blend calculations, and this skill defines what qualifies and what doesn't.

The Bar

A currency belongs in db/seeds/pegs/ only if all of the following are true:

  1. Officially asserted by an issuing authority (central bank, monetary authority, currency board, or government).
  2. Currently in force — not historical. If a peg ended, remove the entry; don't keep it with a sunset date.
  3. A specific rate is asserted, not a band, target, or "managed float."
  4. A primary source exists: the issuing authority's own page, a treaty, or legislation. Wikipedia is acceptable as a fallback for long-standing colonial / dependency pegs (FKP, SHP, GGP, IMP, JEP, BMD, BTN, MOP, CVE, ANG, QAR, OMR) where the authority doesn't publish a dedicated peg page, but a central-bank URL is preferred whenever available.

If any one of these fails, the currency does not belong in the file.

What Does Not Qualify

  • De facto pegs: stable in practice but never officially declared. Example: AZN/USD has been flat at 1.7 since May 2017, but CBAR has not asserted a peg. Adding it makes us responsible if it breaks.
  • Crawling pegs / managed floats: the rate moves within a band (e.g., CNY) or is "managed" without a fixed target.
  • Currency boards with derived rates: if the rate is mechanically derived from another (e.g., dollarization), the currency is its base — no peg row needed unless there's a non-1 multiplier.
  • Historical pegs: if a peg has ended, it does not belong here. Look up the current regime.
  • Forecasts or expectations: "expected to peg" or "will likely peg." Wait until it's official.

Schema

Each entry in db/seeds/pegs/:

json
{
  "quote": "AED",
  "base": "USD",
  "rate": 3.6725,
  "since": "1997-11-02",
  "authority": "Central Bank of the UAE",
  "source": "https://www.centralbank.ae/en/our-operations/currency-operations/exchange-rates"
}

All six fields are required (enforced by Peg = Data.define(...) in lib/peg.rb):

  • quote — the pegged currency (ISO 4217)
  • base — what it's pegged to (ISO 4217)
  • rate — 1 base = rate quote. Default 1.0 for parity pegs.
  • since — date the current peg took effect, ISO 8601. Used to suppress peg-derived rates before this date.
  • authority — the human-readable name of the asserting body.
  • source — a stable URL. Central-bank page preferred; Wikipedia acceptable for long-standing dependency pegs.

Adding an Entry

  1. Find the primary source. Search the central bank or monetary authority's website. Look for "exchange rate policy," "monetary policy," or "currency arrangement." If only Wikipedia turns up something, check whether the bank's own site mentions it elsewhere — sometimes the peg is buried under a different title.
  2. Confirm the rate is current. Some pages cite historical rates that have since been revised (e.g., Saudi riyal has had multiple regimes; the current peg dates to 1986). Match since to the current peg, not the original one.
  3. Add to db/seeds/pegs/ as <quote>.json (lowercase, e.g. aed.json).
  4. No code changes needed — Peg.all auto-discovers files in the directory.
  5. Add a test case to spec/peg_spec.rb if the entry has unusual structure (non-1 rate, non-USD base, etc.) — for parity USD pegs, the existing tests cover it.

Removing an Entry

If a peg is officially abandoned (e.g., 2015 CHF/EUR style), remove the entry. Do not leave it with an until field — the schema doesn't support one and the rate becomes wrong the moment the peg breaks.

If you discover an entry that doesn't meet the bar (a de facto peg slipped in), remove it.

Show full SKILL.md (348 more words)Show less

How Pegs Are Used

Pegs are treated as a source of rate data alongside providers. They contribute when the caller has not restricted the source set via ?providers=. Two places in the codebase consume the peg files:

  1. Currency.find / Currency.all (lib/currency.rb) — synthesizes a currency record for pegged currencies that have no provider coverage of their own (e.g., FKP). Without a peg, these would not appear in /v2/currencies.
  2. PegAnchor (lib/peg_anchor.rb) — wraps Blender and applies all peg behavior in one place. It substitutes the peg rate for pegged quotes (matched-base or cross-base via the peg's base as a bridge), synthesizes rows for pegged currencies that providers do not cover, and rebases output to the user's base when the request base is itself pegged.

Cross-base requests like ?base=EUR&quotes=AED are anchored through the peg's base: the result is blended(EUR/USD) × peg(USD→AED) rather than blended(EUR/AED). This removes provider-disagreement noise on quantities the issuing authority has fixed.

When the caller scopes via ?providers=, RateQuery bypasses PegAnchor and uses Blender directly. Pegs are excluded along with all other unlisted sources, so requests like ?base=BMD&providers=ecb (where ECB does not publish BMD) return empty rather than synthesizing peg-derived rates.

Why the Bar Matters

Frankfurter's editorial principle is surface uncertainty, don't impose judgement. Adding a de facto peg means we'd be asserting a peg that the issuing authority has not. If that peg breaks, we'd be the source of stale or wrong data — not because a provider got it wrong, but because we decided what reality looked like.

The bar exists so that anything in db/seeds/pegs/ is defensible by appeal to a primary source. If a user asks "why does Frankfurter say AED is exactly 3.6725?", the answer is "because the Central Bank of the UAE says so" — not "because we observed it was usually that."

Reference: Currently Listed Pegs

All entries in db/seeds/pegs/ are GCC dollar pegs, GBP-area dependencies, USD-area dependencies (Caribbean), or escudo/INR/HKD pegs with treaty backing. There are no de facto pegs in the directory.

If you propose an addition, check that it fits one of these established categories or has a comparably strong source.

© lineofflight, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/evaluating-pegs of lineofflight/frankfurter.

Open the folder on GitHubat commit 71334f7

Compare with similar skills

Evaluating Pegs next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Evaluating Pegs compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Evaluating Pegs this skilllineofflight/frankfurter2k—~1.6kAutomated safety check: PassMIT
Gumroad Prod Consoleantiwork/gumroad9.8k—~2.9kAutomated safety check: NotesMIT
Fastlane Pull Request Reviewfastlane/fastlane42k—~550Automated safety check: PassMIT
Antipattern Preventiondoorkeeper-gem/doorkeeper5.5k—~1.1kAutomated safety check: PassMIT
Mutantmbj/mutant2.2k—~2kAutomated safety check: PassProprietary
Swig CI Reproswig/swig6.3k—~1.2kAutomated safety check: PassCustom licence

Similar skills

  • Gumroad Prod Console

    antiwork/gumroad

    Execute read-only Ruby/Rails commands against Gumroad's production database for debugging and investigation.

    9.8k GitHub stars~2.9k tokensUpdated yesterday
    DevelopmentAuto-check: notes
  • Reviews a fastlane pull request against its linked issue and the project guides, separating blocking from non-blocking findings and handling vulnerabilities privately.

    42k GitHub stars~550 tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Antipattern Prevention

    doorkeeper-gem/doorkeeper

    Avoid common Ruby and Rails antipatterns that degrade maintainability and performance.

    5.5k GitHub stars~1.1k tokensUpdated yesterday
    Backend & APIsAuto-check passed
  • Mutant

    mbj/mutant

    Run mutant, read mutation reports, fix alive mutations, and verify coverage.

    2.2k GitHub stars~2k tokensUpdated 6 days ago
    Testing & QAAuto-check passed
  • Swig CI Repro

    swig/swig

    Reproduce a GitHub Actions Linux CI failure locally when it does not happen on your machine: a podman/docker image that mirrors the ubuntu-22.04 runner by reusing the real Tools/CI-linux-.sh install…

    6.3k GitHub stars~1.2k tokensUpdated 2 days ago
    DevOps & CloudAuto-check passed
  • Dependency Updater

    Asvarox/allkaraoke

    Smart dependency management for any language. An agent skill from Asvarox/allkaraoke.

    261 GitHub starsUsed in 4 repos~3.5k tokens
    DevelopmentAuto-check passed

More from lineofflight/frankfurter

  • Wise API

    lineofflight/frankfurter

    A skill your agent uses when querying Wise for exchange rates (real-time or historical), validating Frankfurter rates against Wise mid-market, debugging rate discrepancies, or when the user mentions…

    2k GitHub stars~1.1k tokensUpdated 6 days ago
    Auto-check passed

Works with

Questions about Evaluating Pegs

What does Evaluating Pegs do?

A skill your agent uses when adding, evaluating, or removing an entry in db/seeds/pegs/, when the user mentions a pegged or fixed currency, or when an issue suggests we should "pin" or "lock" a…. Evaluating Pegs is an agent skill from lineofflight/frankfurter. Use when adding, evaluating, or removing an entry in db/seeds/pegs/, when the user mentions a pegged or fixed currency, or when an issue suggests we should "pin" or "lock" a currency to another.

When should I use Evaluating Pegs?

Evaluating Pegs fits situations like: removing an entry in db/seeds/pegs/; the user mentions a pegged; an issue suggests we should pin; lock a currency to another.

How do I install Evaluating Pegs in Claude Code?

Run `npx skills add lineofflight/frankfurter --skill evaluating-pegs -a claude-code`. Or copy the skill folder (.agents/skills/evaluating-pegs in lineofflight/frankfurter) into .claude/skills/evaluating-pegs in your project. Claude Code loads it when a task matches its description.

How do I install Evaluating Pegs in Codex?

Run `npx skills add lineofflight/frankfurter --skill evaluating-pegs -a codex`. Or copy the skill folder (.agents/skills/evaluating-pegs in lineofflight/frankfurter) into .agents/skills/evaluating-pegs in your project. Codex loads it when a task matches its description.

Can I use Evaluating Pegs in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add lineofflight/frankfurter --skill evaluating-pegs -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/evaluating-pegs, .gemini/skills/evaluating-pegs, .github/skills/evaluating-pegs and .opencode/skills/evaluating-pegs in your project.

What does Evaluating Pegs need to run?

SKILL.md names no scripts, command-line tools or credentials: Evaluating Pegs is instructions for the agent only.

Does Evaluating Pegs access the network?

SKILL.md names 1 domain. In commands or code: centralbank.ae; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Evaluating Pegs safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Evaluating Pegs use?

Evaluating Pegs is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Evaluating Pegs use?

About 1.6k tokens (SKILL.md is roughly 6.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Evaluating Pegs?

Skills that share tags, products or a category with Evaluating Pegs: Gumroad Prod Console (antiwork/gumroad, 9.8k stars), Fastlane Pull Request Review (fastlane/fastlane, 42k stars), Antipattern Prevention (doorkeeper-gem/doorkeeper, 5.5k stars) and Mutant (mbj/mutant, 2.2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Evaluating Pegs?

lineofflight (a GitHub organization) maintains it in lineofflight/frankfurter, which has 1,955 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 2, 2026.

Source: lineofflight/frankfurter on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.