More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Reference Hunt: Build It Like the Reference

    1

    When "like this" is the only spec, this skill turns working code into a confirmed semantics summary, then a native reimplementation verified point by point.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Reference Hunt: Build It Like the Reference

    Reference Hunt: Build It Like the Reference

    Example session with this skill installed

    Our Python job worker needs retry behavior like the Go SDK our platform team uses — exponential backoff with jitter, it just feels right. Extract the spec from it before we build anything.

    • Read your context and instructions
    • Compiled the reference hunt

    SEMANTICS SUMMARY — produced by applying the skill (extraction stage; implementation follows your confirmation).

    Reference: the platform team's Go retry package (internal, v2.3, read in full — 340 lines). License: internal code, learning permitted. Dimension: retry behavior and error shape only — not its logging or metrics.

    Behaviors and guarantees: up to 4 attempts total; delay starts at 200ms, doubles per attempt, capped at 8s; full jitter applied to each delay; only errors implementing a Retryable() check are retried — everything else fails immediately; context cancellation aborts mid-sleep, not just between attempts; after the final attempt the caller gets a typed ExhaustedError carrying the attempt count and the last error, never a bare timeout.

    Deliberate vs. incidental: the Retryable() gate and cancellation-during-sleep are deliberate (documented, unit-tested). The 200ms base looks incidental — no comment, no test pins it; propose confirming with the platform team or adopting as-is knowingly. One inconsistency found and flagged, not copied: the first retry ignores the cap check, so a large configured base could overshoot 8s once.

    Will not translate: Go's context cancellation has no direct Python equivalent in your worker — proposed equivalent is a threading.Event checked in 50ms sleep slices, which preserves the abort-during-sleep guarantee with minor granularity loss. The typed error maps to a dedicated exception class in your error module.

    Gaps the reference does not cover: your worker runs jobs with side effects — the Go SDK assumes idempotent calls. The summary names this as a design gap: before implementation, decide whether retries require an idempotency key per job. That decision is yours, and it is now on paper instead of in a postmortem.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Some requirements cannot be written down — "make it feel like that one," "handle retries the way this library does." Descriptions fail; pointing works. This skill treats the pointed-at code as the specification and reads it like one. First it qualifies the reference: does it actually work, is it the right dimension, is it small enough to understand, does its license permit learning from it? Then it extracts a semantics summary — the behaviors and guarantees stated as promises with numbers, each decision classified as deliberate (imitate) or incidental (question), the parts that will not translate paired with target-stack equivalents, and the gaps the reference never covered named before they become production surprises. The summary is confirmed with you before any code is written, because a misread spec is cheapest to fix at that moment. Implementation then happens natively — the reference defines what, your codebase defines how — tracked in a mapping table that becomes the verification checklist. The hunt closes with a point-by-point walk: every behavior located in the new code, every deliberate decision preserved or consciously changed, every divergence justified in writing. You get the summary template, an extraction checklist, an equivalence rubric, and a worked example, plus edge cases for black-box references, disagreeing references, and references that evolve mid-hunt.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    • It needs a confirmable summary: if nobody can judge whether the extraction is right, it stops at the summary rather than building on a guess.
    • Black-box references (binaries, hosted services) yield inferred behaviors, which it labels as inferred — verified harder, but never as certain as read code.
    • It will not produce a pixel-for-pixel or line-for-line clone; if exact copying is the requirement, that is a different job with legal implications this skill declines.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Permissions

    No special permissions declared or detected

    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    Sometimes the license forbids it, and even when it does not, transliterated code reads as foreign in its new home and misses the simpler native solution. The summary-first route also gives you a document you can verify the result against — adapted copies have no spec to check.

    The extraction classifies decisions as deliberate or incidental and surfaces suspected bugs in the summary rather than reproducing them. Fidelity is to the semantics you confirm, not to the reference's accidents.

    Small enough to read fully is ideal. For a large system, the hunt narrows to the subsystem that carries the dimension you are borrowing — one dimension per hunt — and says so in the summary.

    New in Code Quality & Review