cross-posted from: https://lemmy.org/post/6151646
I’ve been running deep research with agents for the past few weeks on one question: what is the most promising future for cheap, fully local AI-driven software engineering?
After weeks of deep-research agent runs, the most recent and promising stack for cheap, fully local AI-driven software engineering found by 5 agents was:
Qwen4 27B + CoDoc
Turns out that the answer was David and the rock.
Qwen4 27B (David). Quantized, it should fit on a single 24 GB consumer GPU. The coding capability at this size is now good enough for the bulk of day-to-day engineering work provided the agent has the right context.
CoDoc (the rock). This is a proposed standard where every software library ships AI-optimized documentation inside the package itself:
docs/README.mdas entry point,docs/index.mdas catalog, plain markdown throughout. Version-matched by construction, offline, deterministic. In the JavaScript ecosystemnpm installputs the docs on disk next to the code.According to the research agents: the bottleneck for a 27B local model is not raw intelligence, it’s the context. A small model hallucinating a v5 API is a context problem, not a capability problem and CoDoc fixes the context for free.
The evidence in the white-paper points in the same direction:
- Vercel’s own agent evals on Next.js 16 APIs (absent from training data): 100% pass rate with bundled docs + an
AGENTS.mdpointer, vs 53% without. The on-demand “skill” variant maxed at 79% and was never even invoked in 56% of cases.- The unknown European IT company, Amadeus, claims that they have observed reduction in hallucinated APIs, the use of deprecated patterns and repeated correction cycles but they do not provide any rigorous evidence beyond these statements. They say that they intend to develop CoDocBench to address this gap.
Now the Goliath part. The big labs’ and hyperscalers’ moat was never the model: open weights are commoditizing fast. Their moat is the paid context layer: RAG pipelines, hosted doc intermediaries, MCP servers, enterprise knowledge add-ons, etc. According to the research agents: CoDoc collapses that entire layer into
npm installor the equivalent in each ecosystem. A standard that makes context free, local, and version-pinned is an existential matter for anyone monetizing context scarcity.And now the best part, the timing :) The AI bubble is popping as I type this. Goliath’s capital expenditure thesis requires inference to keep getting more expensive and cloud dependency to keep deepening. With David and his rock, a decent modern laptop doing your engineering agent’s job for electricity money is Goliath’s worst nightmare.
The standard itself comes from an unknown European IT company, not from any lab, which is exactly why I believe it adds to its credibility (despite its lack of first-hand evidence): it has no incentive to route your context through a metered API or sell you tokens, quite the contrary, it has all the incentives to make inference as cheap as possible.
I have read CoDoc’s white-paper and while it is far from perfect, I do mostly agree with the output of the research agents that picked up on Qwen4 27B + CoDoc as the most promising future for cheap, fully local AI-driven software engineering.
And you, do you think that it is game over for the AI Goliaths?
This is lit and this is it.
Help me out here. How is this actually different from normal software documentation distribution besides the standardised location for it? The Linux ecosystem has had docs as part of packages long before AI, most projects do require me to read the readme, except the ones that create a separate website like react-query which have always been a pain in the ass but exist to provide ad revenue. Why would projects decide to use this method which further bypasses their potential alternative revenue streams or existing documentation? What project with already poor documentation is going to adopt this and suddenly create good documentation?
Sure, I might actually need a bit of help myself for your first question ;)
What do you mean by: “How is this actually different from normal software documentation distribution besides the standardised location for it?” Could you provide some examples and explain a bit more what you mean by normal software documentation distribution?
Thank you for bringing up the Linux ecosystem. This example is real but notice who ships the docs: the distro maintainers, not upstream. Debian and friends ship man pages in the main package (although some argue that this practice is dying) and the longer prose docs are often split into separate
-docsub-packages, which is the ‘second box’ argued against in the white paper (section 3.5). The upstream artifact usually ships light-weight documentation such as the README.md file and a URL for more thorough documentation.More importantly, AI coding agents do not usually work against distro packages. They work against npm, PyPI, Maven, crates.io, etc. In most of these ecosystems, the norm is code plus a thin README that points at a website.
The react-query example you mention isn’t quite the exception for complete thorough documentation outside of the installed artifact. We have: docs.rs, Read the Docs (For 2021, Read the Docs reported 700 million page views and 196 million unique visitors - it would be awesome if we had more recent stats but could not find any), GitHub Pages, vendor portals, etc. The README that ships with the package is usually a logo, a one-liner, an install snippet and a link. It’s a pointer, not full documentation inside the installed artifact.
Besides the standardised location, CoDoc is doing a lot more than meets the eye. Location might be the least of it:
- A catalog index (
index.md) so an agent reads only what’s relevant, within context limits - Version-matching by construction: the registry artifact is immutable, the docs within the installed artifact are there forever
- Offline and deterministic: works in air-gapped environments, byte-identical every time
- Content designed for the agent: usage guidelines, do/don’t rules, complete runnable examples
- Discovery: the agent can expect docs to be there without a human pointing (if the convention gets widespread adoption, it lives in the models’ training data, not in the repo’s config)
The Linux precedent actually supports the CoDoc proposal. The OS world shipped docs in the box because the consumer on the machine needs them locally. CoDoc extends that logic to the language ecosystems, where the consumer on the machine is now increasingly (and I would dare say primarily) an AI agent that reads files.
If the README were enough, Vercel’s evals wouldn’t show 100% vs 53% on APIs absent from training data. The readme didn’t move that number. Complete, version-matched, bundled docs did.
Now, the last two questions:
Why would projects decide to use this method which further bypasses their potential alternative revenue streams or existing documentation?
First, CoDoc does not take the website away. The docs site stays exactly where it is for humans. As a first step, CoDoc can add a generated machine-readable copy inside the artifact, built from the same source of truth (see section 8.7 of the paper). It is additive. react-query keeps its ad revenue stream, your AI coding agent just stops inventing v5 APIs.
Second, the incentive is being chosen as the library for your project. Section 7.3 in the paper discusses the virtuous cycle for libraries that adopt CoDoc: libraries that work well with agents get picked, so maintainers ship docs to stay competitive. This is not hypothetical at all. Design Factory and Next.js now ship their full documentation inside the package, and Vercel’s own evals quoted above are what measured the effect. The TypeScript ecosystem already lived through this transition before. It is best read in Section 12 of the paper. Developers will start asking “does it ship with CoDoc?” the same way they asked “does this library have first-party types?”.
“What poorly documented project is going to adopt this and suddenly write good docs?”
None of them, and CoDoc does not pretend otherwise. CoDoc is a proposed industry standard. Section 8.7 says this out loud under “a note on documentation maturity”. It cannot manufacture documentation that does not exist. The paper gives libraries an incremental ladder (see section 10.9)
P.S. With your genuinely good questions, you forced me to go back to re-read the paper and do some research. I am now more convinced that CoDoc is the way forward for cheap, fully-local AI-driven development and that there really is a place for CoDoc as a cross-ecosystem standard.
- A catalog index (


