- Home
- Skills
- Code Quality & Review
- Source-Driven Development: Docs-First Building
More screenshots
Works with the AI Agents you already use
Source-Driven Development: Docs-First Building
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
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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