#automation

A single script that turns a project's Markdown documentation into a static site that opens from a folder with no server or internet: a menu, a table of contents that follows the reader, tables that never truncate, code with a copy button, and links that keep working.

Four commands that move a stack from its old layout into a new structure across major versions: export without changing the source's data, import each store the way its version allows, verify what really arrived, and rename modules while moving their data along.

Commands that version every module of a stack on its own, build its image under a tag that means exactly one build, refuse to reuse a version or swallow a failed compile, and archive images by name and tag so versions never overwrite each other.

One command that rotates an environment's internal credentials key by key: a dry run by default, a backup first, a unique value for every key, a real login to prove each credential that can log in, and rollback for any that fail.

Two commands that keep three environments apart on one machine and one web server: one sets an environment's addresses and aligns every file that stores them, rendering nginx from templates and refusing on clashes; the other points the browser at one environment.

Three commands that take a tested release into production without overwriting what production owns: they promote configuration structure but keep its secrets and addresses, refuse to copy new secrets, and apply schema migrations the images carry.

Three commands that build a full copy of production for one release — configuration from the repository, images from the registry, data from the latest backup — restore it in order, run the release's migrations against that data, and remove it without a trace.

Three commands that back up a running Docker stack — PostgreSQL, MinIO, and Elasticsearch — without downtime, restore it to any point, and keep retention safe, with exit codes that say how much a failure matters.

The procedure that gives a new project its whole infrastructure from generators, in the order the stacks depend on each other: log first, then storage and broker, then the gateway, then the application — with the public steps kept manual.

Templates come from real stacks, and copies quietly carry their data, keys, open databases and root-owned paths. My database, object storage and application generators leave the old data, keys and access behind, and read each application's facts from the application itself.

Every project gets its own OpenTelemetry Collector, Elasticsearch and Kibana from one command, showing data on dashboards from the first start, by owning the data directory, starting services in the order they need, and keeping the official mappings on one node.

Every new project needs a gateway, sign-in, and a first administrator before its backend exists. One generator command now builds that stack, working on first boot, by handling the values that fail silently when set by hand and a rerun that would keep the old database.

The procedure that turns a month of commits into a report a non-technical reader can follow: an AI agent reads, groups, drafts, and captures code evidence behind checks, while I sign in to the code hosts and review the result.

The procedure that turns each new chapter of a story into a narrated video: an AI agent runs every stage behind gates that refuse unfinished work, while I start each stage, review the chapter, and render it myself.

The shape I give small tools: one file, one job, sections in a fixed order, an exit-code contract at the top, and three ways in for input — plus its Bash variant for generators, and when a tool outgrows it.

A single Python script that proves S3-compatible storage is ready before an application depends on it, by using every bucket the way a real client does and catching the failures that return HTTP 200.

A Colab runtime has no address anyone can call, so a laptop and a borrowed GPU talk through a broker both of them dial out to. Sending commands was the easy half. Knowing — whether the worker is alive, whether a command arrived once — is where six silent failures hide.

Every search result gives the same answer for this: a LibreOffice command. I use a different engine, for four specific reasons — and the rest of the tool is the cost of talking to a converter built for a document server rather than for a command line.

A recording is two halves and usually only one is broken. Cleaning up the audio repeatedly, without watermarks or caps, needed a filter already compiled into ffmpeg — and eight further decisions that had nothing to do with noise, including the one whose proof is a matching hash.

Editing, building, and flashing had all moved to the terminal; reading serial output was the one job still holding a vendor IDE open. Replacing it took a program already on the machine, plus six decisions the IDE had been making silently.