Growing a 454-page ML reference manual in 5 days: permacomputer harvest
########################################################################

:author: Russell Ballestrini
:slug: growing-a-book-in-5-days-ml-and-devops
:date: 2025-10-16 12:00
:tags: Machine Learning, DevOps, Automation, Python, Project, Docker
:status: published

We just harvested `uncloseai: Machine Learning Inference Client Reference Manual <https://shop.unturf.com/p/8486f492-a93e-11f0-b477-02dfe05770ee/uncloseai-machine-learning-reference-guide-to-inference-clients>`_. 454 pages. 58 implementations across languages. 5 days from seed to harvest (October 11-16, 2025).

.. image:: https://make-post-sell-files.nyc3.cdn.digitaloceanspaces.com/5f81d674-c7c8-11ec-9432-eb3419618d4a/8486f492-a93e-11f0-b477-02dfe05770ee/thumbnail1
   :alt: uncloseai Machine Learning Reference Manual book cover
   :width: 50%
   :target: https://shop.unturf.com/p/8486f492-a93e-11f0-b477-02dfe05770ee/uncloseai-machine-learning-reference-guide-to-inference-clients

This seems like permacomputer agriculture. We don't write books. We grow them.

a permacomputer
================

At `unturf. <https://www.unturf.com/>`_ we're building a permacomputer. Not a machine. An ecosystem.

Permaculture grows food by working with nature instead of against it. Plant the right seeds, create the right conditions, let systems self-organize & harvest continuously.

Permacomputer grows software the same way. Plant code templates, create automation pipelines, let ML models generate variations & harvest continuously.

Traditional software development: manual labor, row crops, monoculture.

Permacomputer: polyculture, automation, continuous harvest.

the seed
========

Day 1: plant reference implementations by hand.

Python with requests. Python with httpx. C with libcurl.

These are seed stock. Genetic templates. Everything else grows from these.

All 58 implementations live in the open in the `languages directory <https://git.unturf.com/engineering/unturf/uncloseai.com/-/tree/master/languages>`_ - a git repository of public domain code. Clone it, fork it, grow new software from these seeds.

Each implementation contains the DNA:

- HTTP client patterns
- Request formatting
- Response parsing
- Error handling
- Streaming support
- Docker containerization

the growth cycle
================

**Days 2-3: propagation**

ML models read the seed implementations & generate variations across languages. We provide reference patterns & the model adapts them to each language's idioms & libraries.

Rust, Zig, Odin, Nim, Crystal, JVM languages, .NET, functional languages, scripting languages. Each implementation follows the same API patterns but uses language-native approaches.

**Days 2-4: automated cultivation**

Every implementation goes through Docker build & validation. Each one must:

- Build successfully in isolated container
- Discover models from environment variables
- Handle streaming responses correctly
- Generate text-to-speech output
- Pass integration tests

Failed builds get regenerated. The cycle repeats until all tests pass. Wake up to 10-15 new implementations tested & validated.

**Days 4-5: harvest**

ML generates documentation from working code. We review, edit, format & assemble the book.

Template → generation → validation → harvest.

a permacomputer mindset
========================

**1. ML as mycelium**

Mycelium breaks down organic matter & distributes nutrients. ML breaks down reference code & distributes patterns across languages.

Not replacement. Decomposition and propagation.

**2. Automation as irrigation**

Set up the system once & it runs continuously. Docker builds, tests, validation.

No manual watering. The system waters itself.

**3. Quality seeds = quality harvest**

First 3 implementations took careful work. Every subsequent implementation inherited that quality.

Invest in seed stock. Harvest scales automatically.

**4. Version control the genetics**

Prompts are genetic code. Version controlled, A/B tested & iterated daily.

Prompt engineering is genetic engineering.

**5. Solo operator, ecosystem leverage**

One person. One permacomputer. 58 implementations in 5 days.

Not through heroic effort. Through ecosystem design.

the harvest
===========

- 454 pages
- 58 tested implementations
- Complete Docker configs
- Public domain code (`git repo with all 58 implementations <https://git.unturf.com/engineering/unturf/uncloseai.com/-/tree/master/languages>`_)
- $42, includes free uncloseai.com API access

More importantly: proved permacomputer can grow technical reference material at scale.

the evolution
=============

unturf. is a loose-knit collective of hackers disrupting wheels & fostering open collaboration.

We run `uncloseai.com <https://uncloseai.com/>`_ - free machine learning inference services.

We operate `git.unturf.com <https://git.unturf.com/>`_ - public domain code repositories.

We're growing Remarkbox, MakePostSell & now uncloseai as permacomputer crops.

Not a company, an ecosystem of software permaculture.

The same patterns that grew this book in 5 days grow everything:

- API documentation
- Code example libraries
- Multi-language SDKs
- Tutorial content
- Technical training materials

Plant seeds, build automation, let ML propagate & harvest continuously.

Traditional publishing: manual labor at typing speed.

Permacomputer publishing: automated cultivation at validation pipeline speed.

Not one person writing code.

A collective cultivating an ecosystem.

Disrupting wheels. Fostering open collaboration. Making Machine Learning accessible.

The book grew in 5 days because we planted the right seeds in the right soil with the right automation & cultivation pipeline.

Permacomputer agriculture.

Join us: `unturf. <https://www.unturf.com/>`_

Grab the harvest: `uncloseai reference manual <https://shop.unturf.com/p/8486f492-a93e-11f0-b477-02dfe05770ee/uncloseai-machine-learning-reference-guide-to-inference-clients>`_

.. contents::
