The tools and patterns I actually keep coming back to.

The list makes more sense when the choices behind it come first.

• Ship a coherent slice

  Incremental delivery

  I prefer a small end-to-end path that works over several unfinished layers. Real use exposes the next change more clearly than a large speculative plan.

• Spend complexity deliberately

  Measured complexity

  I accept complexity when it buys control, performance, or recovery that matters. Otherwise it is maintenance without a return.

• Keep the system visible

  Observable behavior

  If I cannot observe, explain, and repair a system, I do not trust it yet.

The main workstation is consistent. Remote environments stay close to the machines they run on.

• Local and remote operating systems

  macOS · Raspbian · Ubuntu · Oracle Linux

  macOS is the main development environment. I use Linux where the target or host calls for it instead of forcing every machine into the same shape.

• Editors that match the machine

  VS Code · gedit · vi

  VS Code handles sustained work. gedit and vi are useful when I am already on a Linux host and the change should stay small.

• Shells are part of the environment

  zsh · bash · csh

  I use zsh locally and work with bash or csh where the environment already depends on them. I do not standardize a shell for its own sake.

I favor ordinary, well-understood parts when they fit the deployment and data path.

• Service runtime

  Node.js · Express

  I use them for backend services that need clear boundaries, practical deployment, and behavior that stays understandable over time.

• Web surface

  TypeScript · Next.js

  Next.js is useful when the web interface and server behavior need to ship together. This site is built with it.

• API-heavy tools

  Python · FastAPI

  FastAPI is a good fit when an API owns operational state and needs explicit validation, permissions, and health behavior. Registry Control Plane uses it that way.

• Data layer

  SQLite · MySQL · MariaDB

  SQLite fits embedded and local work. MySQL and MariaDB fit service-backed systems. The deployment and access pattern set the choice.

The useful part is not merely packaging a service. It is keeping the build, image path, and recovery route inspectable.

• Small servers, physical and virtual

  Cloud VMs · Raspberry Pi

  I use both small cloud systems and small physical systems. Either one still needs maintenance, resource limits, and a recovery plan.

• Container delivery

  Docker · Podman · Docker Compose

  Containers are the default path for repeatable personal services. Compose keeps the runtime shape readable without pretending the environment has disappeared.

• Ingress when it is useful

  Cloudflare · Cloudflare Tunnels

  I use them for routing, temporary access, and recovery paths when they simplify the edge of a service.

  Boundary: A tunnel is not a substitute for understanding the network path or removing temporary access after recovery.

• Self-hosted build and image path

  Forgejo · buildx · private registry

  Forgejo runners and Buildx handle validation, bounded caching, tagging, and image publication through a registry I operate.

I use open systems where custom routing, private access, or local automation is worth the maintenance.

• Open router firmware

  OpenWrt · Linksys WRT · Velop

  OpenWrt exposes routing, firewall, wireless, package, and upgrade behavior that consumer interfaces often hide.

  Boundary: I use custom arrangements where control matters more than appliance-style simplicity, not on every network by default.

• Private access and DNS

  WireGuard · Unbound

  They provide private access I can trace and DNS behavior I can inspect without handing the whole path to an opaque service.

• Local automation

  Home Assistant · Bluetooth presence · smart plugs

  I keep automations local-first, predictable, and useful enough to quietly earn their place.

The model is only one part of the system. Hardware, memory mapping, backend behavior, retrieval, and orchestration all shape the result.

• Unified-memory AMD workstation

  AMD Strix Halo · 128 GB unified memory

  The system gives me room to test large models and long contexts while keeping the whole environment local.

• Model serving and backend inspection

  Ollama · Lemonade · ROCm · llama.cpp

  Ollama handles day-to-day model serving. I am also interested in using Lemonade to experiment with NPU-targeted models, and I work closer to ROCm and llama.cpp when the load path or backend behavior needs investigation.

• Systems around the model

  Retrieval · orchestration · coding agents · tool use

  I use the lab to test the systems around inference, including retrieval, routing, coding agents, and tools that need to stay useful outside a demo.

  Boundary: Measurements stay scoped to the exact hardware, model, context, and backend under test.