source-driven-development

Detect dependency versions and implement framework code from official documentation.

Updated Apr 2, 2026
One-click install
npx skills add https://github.com/logo-solutions/NAS-logo --skill source-driven-development-logo-solutions
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: source-driven-development
Source: https://github.com/logo-solutions/NAS-logo/tree/main/skills/source-driven-development
Command: npx skills add https://github.com/logo-solutions/NAS-logo --skill source-driven-development-logo-solutions

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents unreliable, memory-based framework implementations by ensuring every framework-specific decision is verified against authoritative documentation so users receive correct, up-to-date, and auditable code.

Core Features & Use Cases

  • Dependency and version detection: Reads dependency files to determine exact framework and library versions before making implementation decisions.
  • Targeted documentation fetching: Locates and extracts the specific official docs pages or anchors needed for a given API or pattern rather than relying on generic sources.
  • Docs-driven implementation and citation: Implements code that follows the documented API signatures and migration guidance, surfaces conflicts with existing code, and includes full-source URLs and quoted passages for verification.
  • Use case: When updating form handling in a React app, detect React version from package.json, fetch the precise React docs for the recommended pattern, implement the change per docs, and show the sources.

Quick Start

Ask the skill to detect project dependencies, verify the relevant official documentation for the requested framework pattern, implement the pattern according to those docs, and include full source URLs.

Frequently Asked Questions about source-driven-development

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I verify framework-specific code against official documentation?

Verifying framework-specific code against official documentation involves detecting exact library versions from dependency files, fetching deep-linked documentation pages for relevant APIs, and implementing code to match documented patterns with full source URLs and quoted passages for verification.

What is source-driven development for framework implementation?

Source-driven development for framework implementation grounds every code decision in authoritative official documentation, preventing unreliable memory-based implementations by detecting versions from dependency files and citing exact API signatures for auditable code.

How do I implement framework patterns using detected dependency versions?

Implementing framework patterns using detected dependency versions requires reading dependency files to determine exact framework versions, fetching targeted official documentation pages for the requested APIs, and writing code that follows documented migration guidance and signatures.

Does this approach work with any web framework or library?

This approach works across web frameworks and libraries where exact API signatures and migration guidance matter, making it suitable for building, reviewing, or refactoring framework-dependent features in any project with detectable dependency files.

What's the best way to avoid outdated API usage when refactoring framework code?

The best way to avoid outdated API usage when refactoring framework code is to fetch precise official documentation pages for the relevant APIs after detecting versions from dependency files, then implement changes according to the documented patterns and include full source URLs.

Why does my framework implementation break after a library version update?

Framework implementations break after library version updates when code relies on memory-based patterns instead of verified official documentation, making version detection from dependency files and fetching current API signatures essential for correct refactoring.