Source-driven development: every framework choice rests on the official documentation

How to avoid outdated patterns: detect the stack and versions, read the official documentation, follow documented patterns and cite the sources. The signs that you are working from memory.

Methodologymetodologiadocumentazioneaffidabilitàingegneria del software19 November 2026 · updated 19 November 2026 · 3 min read

"I think it works like this" is a sentence a software project pays for later. Libraries change, functions are deprecated, and code written from memory carries the patterns of three versions ago. Source-driven development proposes a simple rule: every choice that depends on a framework rests on its official documentation, and says so.

The process

1. Detect stack and versions. Before writing code you read the project's dependency files (for example the ones that list packages and versions). A rule holds for a version: without knowing which, you do not know whether it is right.

2. Read the official documentation. For the feature you need, you consult the framework's documentation for the version in use, not a blog post or a forum answer. If the exact version cannot be found, you say so.

3. Follow the documented patterns. You implement as the documentation indicates, even when memory suggests another way. If you decide to depart from it, you explain why.

4. Cite the sources. Every framework-specific decision carries its reference (the link to the page) next to the code or in the description of the change. That way the reviewer can verify in a minute, and whoever reads it a year from now knows where the choice came from.

Why it matters

Assistants and people share a limit: they remember the version they have seen most, not the one the project uses. The deprecated API that appears everywhere in tutorials is the one that gets rewritten several times. An official, dated source turns an opinion into a checkable fact.

The most common excuses

ExcuseReality
"I know this library well"Which version? Interfaces change, and the memory is of another one.
"It only takes a second to look up, but I'll carry on meanwhile"The lookup costs less than a rewrite.
"A tutorial says so"A tutorial is a secondary source, often for another version.

Warning signs

  • Framework-specific code written without checking the documentation for the version in use.
  • Phrases like "I think" or "I believe" about an API instead of a cited source.
  • A pattern implemented without knowing which version it applies to.
  • Forums and blogs cited in place of the official documentation.
  • Deprecated APIs used because they appear often.
  • No reading of the dependency files before writing.
  • Code delivered without references to sources for framework-related choices.

An example

You need to handle data loading in a framework component. The dependency file says the version is 5; the documentation for 5 shows a different way from 4, which is still widely quoted online. You use the one for 5 and add the link to the page in the description of the change. A reviewer checks it in a minute.

When to use it

When you want code with verifiable sources and free of outdated patterns; when working with any framework or library where correctness matters.

This method derives from the open-source agent-skills family by Addy Osmani (MIT licence), rewritten and adapted.

This article is an OIAR skill

What you have just read is the content of a skill from the OIAR catalogue, written for people. Knowledge like this, but richer and deeper, written for the agents, drives the interviews, the analysis and the report inside the platform. Skills are used in OIAR: to try this one on a project of yours you need an account.

source-driven-developmentA method for basing every framework or library choice on the official documentation for the version in use: detect the stack, read the source, follow documented patterns, cite references. Use it when writing code with frameworks or libraries where correctness matters or outdated patterns are suspected.