
Merging a whitepaper used to read as a build promise from the Nano Collective. It wasn't, and we are calling that out. Stage 1 now publishes the thinking. Stage 3, after 30 days of public review, is the build call, recorded on the page with rationale.



The whole NC financial model fits on a napkin. Two destinations for every dollar: running the collective, or the community fund paying OSS bounties via OSC. Split is published in the Economics Charter, with 30 days notice before any change. New terms apply to new work only.


Most open-source orgs won't tell you what's in the fund before you commit a weekend. The Nano Collective charter does: community fund is a mechanism, not a balance, bounty capacity today is effectively zero. You know the shape before you invest.



The Nano Collective doesn't hide a gate behind a 'just ask' form. Stage 0 is a Discord message or a docs issue with your idea, and the answer is usually 'yes, write the whitepaper'. It is a sanity check, not a filter.


$250/mo puts your logo on Nano Collective surfaces. What it does not buy is also on the page: no roadmap influence, no contributor pay decisions, no exclusivity. The offer and the constraint sit side by side, on purpose.



`getmd notes.md` isn't a no-op. While `.pdf`, `.docx`, and `.html` route to their extractors by extension, `.md` skips HTML parsing and still runs frontmatter + structure normalisation. Same CLI, four formats, no flags to remember.


A 1000-page crawl with `--cache` isn't a clever optimisation. It's the normal case.

`get-md` stores successful responses under `~/.get-md/cache`, so reruns hit disk instead of the network. `--cache-max-age` is the only knob that decides whether you re-fetch.


Glue code isn't a step in the pipeline, it's a tax. `getmd --sitemap <sitemap-url>` walks it, recurses nested indices, filters by globs, and writes one .md per page. Docs site to LLM-ready corpus, one command.


1.12GB on your disk. Zero API calls. get-md's local LLM path runs ReaderLM-v2 via node-llama-cpp, so better Markdown conversion costs you storage, not metered tokens.


Most CLIs guess wrong on stdin. get-md sniffs the first bytes: `%PDF` routes to the PDF extractor, anything else gets parsed as HTML. DOCX and Markdown still need a file path, so the autodetect surface is wider than the docs suggest.


Most migration APIs force an all-or-nothing choice: sync or async, end to end.

json-up's createAsyncMigrations() does not. Each up() can be sync or async, freely mixed in one chain. Adopt async work one migration at a time, no global rewrite.


Versioning JSON without a migration path is debt you pay at 2am. The shape of v2 matters less than how data gets from v1 to v2, so json-up keeps the schema and the `up()` in the same object.


A migration throws and the stack trace tells you nothing about which field broke. json-up's ValidationError carries a Zod issues array, so error.issues.forEach(i => console.error(i.path.join('.'), i.message)) prints the exact path and message - the catch tells you what to fix.



Your oldest JSON file has no version field, and that file is the one that breaks first. json-up treats missing version as v0 by default, so every unversioned file in production runs through the same migration chain as a fresh one. No special-case branch for legacy data.


Your data already has rows with a version field, and renaming it is a migration of the migration. json-up's migrate() takes a key parameter, so pass `key: 'version'` (or whatever you used) and nothing breaks. One parameter, no migration of the migration.



Most CLI coding tools need a bespoke editor extension to feel native. Nanocoder just speaks the Agent Client Protocol. Run `nanocoder --acp` and Zed drives the tools, diffs, and permission prompts as a native agent, no extension to maintain.


A 4B model forgetting the question by the second tool call isn't a model problem. It's a prompt problem. Nanocoder's `/tune` `nano` profile shrinks the system prompt from ~700 to ~150 tokens and drops MCP tool sprawl, which is why a small model can actually finish the loop.



Three places a skill can live - project, global, built-in - and only one wins. Project shadows global, global shadows built-in. /skills promote copies a project skill to every repo, /skills demote vendors a built-in into one. /skills show tells you which layer won.



A risky refactor under an agent ties up conversation history, edited files, and your model config in one knot. `/checkpoint create before-refactor` saves all three, so the destructive try costs nothing if it fails.


A custom tool should be one file, not a plugin. nanocoder's tools are .md with a Zod-style input schema, shell-quoting, and an approval policy. Drop it in .nanocoder/tools/, restart, the model calls it.



One JSONL row can be a full conversation. Nanotune keeps every turn in the same `messages` array, so the `/greet` example and the follow-up `/my name is` example train together. `data validate` catches a broken role alternation before you burn GPU on a run.



87% pass rate told me almost nothing. Nanotune's Markdown report groups failures by category. One bucket had every miss, and that was the next training row to write.



An open-ended eval you can't re-run isn't an eval. In Nanotune the LLM judge is a config: provider, model, criteria, threshold in `.nanotune/judge.json`, plugged into a benchmark with `"match": "llm-judge"`. Open-ended now reproduces like string-match.


Throwing more data at a tiny model is not fine-tuning. It's over-training in disguise. Nanotune ships 100–500 examples as the honest default for 0.5B–1.5B models because quality beats volume when the model is small enough to memorise every row.



90 minutes into training and the loss curve went sideways. It wasn't the model. It was the data: duplicate rows, broken turn alternation, missing context messages, all silent. nanotune data validate catches them in seconds, before the hour-long run is wasted.



A VPN hides where the request came from, not what it says. Prompt privacy is a content problem.

prompt-scrub rewrites the prompt before it leaves, swapping emails, paths, and secrets for placeholders. Compose it with whatever network tool you trust; the layers are independent.



A URL with a token in it isn't a URL. prompt-scrub's collision chain picks SecretDetector over UrlDetector when spans overlap, so the bearer gets scrubbed as a secret, not a link. Missing a credential is treated as strictly worse than misclassifying a path.



Your agent's `ls`, `git log`, `cat`, and `grep` outputs go to the next LLM turn in the clear. The cloud sees your repo layout and your hosts file.

prompt-scrub scrubs every message in the array under one session id. The same email maps to the same `Email_1` across the loop.



Most privacy tools bundle the network layer. prompt-scrub won't. It scrubs text and gets out of the way, so your VPN, Tor, or relay stays yours. scrub, send, rehydrate. The boundary is the design.


Generic identifiers like count or id would flood your session map with junk matches. prompt-scrub's CodeTellDetector is dormant by default for that reason. Pass --code-tell-terms with the names you treat as sensitive and it scrubs only those. One flag, your detector.