The idea the whole tree rests on: AI is just software, and an LLM is just a brain. A brain with no hands, no memory, and no tools does nothing. Software, tools, and version control are what turn a model into work. This branch owns the craft — Git, GitHub and code repositories, CI/CD, packages, languages. Where Technology covers the platforms you run on, Software covers how you build, version, review, and ship the code itself.
Strip away the mystique and an LLM is a stateless function: text in, text out. It has no memory between calls, can't take an action, and can't check whether it was right. Everything useful an "AI" does — remembering, calling tools, reading a codebase, opening a pull request, staying correct — is software wrapped around the model. The agents domain says it plainly: agents are software, not prompt soup. This branch is where that bar gets defined: version control, repositories, review, and CI as the discipline that makes both human and agent work compound instead of drift.
Thirteen leaves, from the thesis through to how agents operate and plan inside a repo. Each is written for two readers: the human learning the craft, and the agent that has to operate inside it.
The manifesto. What an LLM actually is (a stateless next-token function), why a brain needs a harness, and why "buying AI" really means buying software discipline. The frame every other node hangs off.
LiveGit as the ledger. Commits, branches, merges, and history as institutional memory — the substrate that makes software reproducible, reviewable, and auditable, for humans and agents alike.
LiveThe repository as system of record. GitHub, GitLab, Bitbucket, Codeberg; pull requests, code review, issues, Actions/CI, releases — and why repos are the layer agents read, write, and ship through.
LiveHow code is organised — monorepo vs polyrepo, README and docs-as-code, branching strategies, and the repo as a knowledge-management surface, not just a code dump.
LivePipelines, tests as gates, and deploy-on-merge. The automation that turns "it works on my machine" into "main is always shippable" — including this site, which auto-deploys from main.
Registries (npm, PyPI, crates, Maven), semantic versioning, lockfiles, and supply-chain risk — the dependency graph every modern build (and every agent install) sits on top of.
LiveHow to choose one, and why it matters less than the discipline around it. Typed vs dynamic, ecosystem and runtime fit, and the languages agents write most reliably.
LiveGoogle's compiled, statically-typed language built for simplicity and scale. Goroutines, single static binaries, fast compiles — the language of cloud-native (Docker, Kubernetes, Terraform), and one agents write reliably.
LiveC/C++ performance with memory safety and no garbage collector — proven at compile time by the borrow checker. Cargo tooling, WASM and embedded reach, and the honest learning curve. The Go vs Rust split, in full.
LiveThe repo as agent context, SKILL.md in version control, agent-authored pull requests, and CI as the agent's safety net. Where this branch meets the Agents domain head-on.
LiveThe backlog is the prompt. Spec-driven development, the backlog as agent-readable data, cadence below the sprint, and what to measure when velocity breaks. The process-level continuation of software-for-agents.
LiveFrom pairing to orchestrating a small fleet. The three execution modes (interactive planning, isolated worktrees, headless batch), orchestrator-vs-peer patterns and their token cost, the three forge-automation layers and their permission traps, and an adoption sequence. Foundation before fleet.
LiveThe model its author told you not to use. Royce's 1970 paper drew the linear model as the thing to avoid; the industry mandated it anyway. The history straight — the misread paper, the DoD codification, the Standish numbers and their dispute — and the honest half: where phase-gated development still fits.
Software is the craft underneath every other branch. It pulls hardest on Agents (agents are software) and Technology (the platforms that software runs on), and it shows up wherever a domain treats its rules as code in version control — Finance, Business, Design.