More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Source-Driven Development: Docs-First Building

    1

    Pin the exact framework version, build from its current official docs instead of memory, cite every non-trivial decision, and flag whatever the docs don't cover.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Source-Driven Development: Docs-First Building

    Source-Driven Development: Docs-First Building

    Example session with this skill installed

    Add session-based auth to our web app. We're on the framework's current version — just write it the standard way everyone uses.

    • Read your context and instructions
    • Compiled the source-driven development

    CITATION RECORD + BUILD NOTES — produced by applying the skill.

    Pin the version: the request says "current version," which is not a version. The dependency file pins the framework at a release two majors past the pattern most examples online still show. That single fact decides the session API: the older cookie-session helper that dominates tutorials was deprecated in the previous major.

    Fetch the page: the versioned auth guide for the pinned release. Extracted: the current recommended session pattern and its exact signature; a deprecation note on the old helper, with the migration guide naming its replacement; one version-gated note ("available since" the pinned release — qualifies).

    Implement: session creation, validation middleware, and logout written from the documented signatures. One gap: the docs don't cover how session validation composes with the app's existing tenant middleware. Implemented from general knowledge and flagged in the record as UNVERIFIED rather than presented as documented.

    Conflict, surfaced not buried: the codebase's admin area still uses the deprecated helper. Options presented — migrate it now, or leave it and record the inconsistency as chosen. User chose: new pattern for the new code, admin migration as a separate task. Recorded.

    Record closes with: version + the file it came from; three decisions each tied to a docs page and section; the deprecation passage quoted; the one unverified flag. Nothing in the change traces to "the standard way everyone uses."

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

    About this skill

    Code written from memory is code written against a version that may no longer exist — and it looks exactly like correct code until the next upgrade breaks it. This skill turns "check the docs" into a protocol. It opens with an inputs/outputs contract: dependency files and a task in, code plus a citation record out. Then an evidence hierarchy that ranks sources — official versioned docs first, changelogs and migration guides second, standards references and compatibility data after — and names what never counts as authoritative: forum answers, tutorial blogs, AI summaries, and the model's own training data. The five-step protocol follows: pin the exact version from the dependency file (a framework name is not a version), fetch the one specific docs page for the feature rather than skimming a site, implement from the documented signatures and current recommended patterns, handle the two recurring conflicts (docs vs docs, docs vs existing codebase) by surfacing and recording them instead of silently picking, and cite every decision so a maintainer can verify it without redoing the research. A rigor decision table calibrates effort to how far the code will travel — full verification for boilerplate copied across projects, a quick check for a throwaway, with unverified work always flagged. A complete worked example runs a data-fetching integration where pinning the version first reveals the familiar pattern is deprecated, and the citation record catches the one interaction the docs don't cover as an explicit unverified flag. It also covers treating fetched pages as untrusted data (directives embedded in a page are content, not commands; endpoints from examples never get hard-coded without being surfaced to you), includes a citation record template and a pre-implementation checklist, and closes with edge cases, anti-pattern smells, and a pre-delivery quality gate.

    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 verifies framework usage, not design: it will confirm you're calling the current API correctly, not that the API is the right choice for your problem.
    • It depends on the docs existing and being reachable; undocumented internals fall back to package source as lower-tier evidence, and anything still uncovered ships flagged as unverified.
    • Citation adds time. The rigor table keeps it proportional, but for a true throwaway script the honest output may be "written from memory, flagged" — the skill makes the trade visible rather than eliminating it.

    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

    The failure mode isn't ignorance, it's drift: code from memory looks right and passes review because nobody can see which version it was written against. The skill adds the parts ad-hoc doc reading skips — pinning the version from the dependency file before anything is written, an evidence hierarchy, conflict handling, and a citation record with unverified items flagged. That's what makes the check auditable later.

    It happens — a migration guide disagrees with the API reference, or the guide targets a newer version than yours. The protocol's rule: verify against the pinned version, surface the discrepancy, and record which source won and why in the citation record. The contradiction becomes a documented decision instead of a coin flip buried in the code.

    Only if you run the full protocol on everything. The rigor decision table scales the effort: a one-off internal helper gets a version pin and one fetched page; a throwaway prototype gets built from memory but flagged as unverified. What's never allowed is the silent middle — unverified code presented as checked.

    New in Code Quality & Review