Uses | Joe Poznanski

Hardware

ASUS ROG Strix (Windows 11 + WSL2 Ubuntu 24.04): WSL2 is the canonical runtime for all scripts, cron jobs, and agent orchestration. Windows handles scheduled tasks and the Rust toolchain compiles equally well from both sides.
Secondary headless server (ares-tron, Linux, Threadripper): Heavy compute, long-running collectors, and GPU workloads live here. LAN + Tailscale mesh keeps it reachable without VPN config overhead.
Tailscale mesh: Zero-config WireGuard overlay across all machines. MagicDNS means I SSH to hostnames rather than IPs even across networks.

Editor and shell

VS Code + Helix (situation-dependent): VS Code for anything with a Claude Code CLI session attached; Helix for quick terminal edits where modal keybindings are faster than reaching for the mouse.
WezTerm: GPU-accelerated, cross-platform, and configurable in Lua without a plugin ecosystem to maintain. Multiplexing replaces most tmux use.
Starship prompt: Fast and context-aware — shows git state, Rust toolchain version, and exit codes without shell-startup overhead.
Zsh + Atuin: Atuin replaces Ctrl-R with a searchable, synced shell history. The delta between remembering a command and finding it in history collapses.

Languages and runtimes

Rust: First choice for anything compute-critical, latency-sensitive, or where I want type-system guarantees at integration boundaries. The WASM pricer and API service are both Rust.
Python: Data pipelines, strategy code, and scripting where the ecosystem (numpy, pandas, scipy) is the right fit. pyright keeps the type boundaries honest.
Node / TypeScript: Frontend build tooling and Astro. TypeScript with strict mode is a prerequisite — untyped JS has too high a per-change reasoning cost.
Bash: Glue scripts and cron wrappers. Kept short and single-purpose; anything that needs real logic gets promoted to Rust or Python.

AI-assisted development

Claude Code CLI: Primary AI pair-programmer for complex multi-file changes, agent swarm orchestration, and anything that benefits from deep codebase context.
Codex CLI: Complementary agent runtime for tasks that benefit from a parallel execution lane or a different model's reasoning style.
Agent swarm patterns: Independent tasks run in parallel lanes with explicit halt-state contracts, SHA sidecar verification, and orphan-runner detection. The overhead pays for itself on anything spanning more than 5 files.

Infrastructure

Cloudflare Pages + Workers: Static frontend hosting with global CDN, zero cold-start, and free analytics. The build-and-deploy pipeline fits in a single pnpm command.
Hetzner CX22: Flat-rate Linux VPS for the Axum API. $3.59/month, no cold-start, predictable latency. Caddy handles TLS termination.
GitHub Actions: CI/CD for the monorepo. The pipeline runs Vitest, TypeScript checks, Playwright, and cargo test before any merge.
SQLite + Litestream: Contact store and local data pipelines. Litestream replicates WAL frames to R2 without a managed database subscription.

CLI tooling

ripgrep (rg): 5-10x faster than grep on large repos. Respects .gitignore by default. The single biggest productivity uplift in the 2026-04-28 tooling rollout.
fd: Replaces find with sane defaults and gitignore awareness. The syntax is intuitive enough to use without consulting the man page.
bat, delta, lazygit: bat for syntax-highlighted cat output, delta for readable git diffs, lazygit for staged hunks and interactive rebase without leaving the terminal.
gh CLI: GitHub API from the shell. PR creation, issue management, and CI status without opening a browser tab.

The philosophy behind this list: prefer terminal-native, prefer composable, prefer tools whose failure mode is loud rather than silent. A tool that silently returns empty results when it can’t find something is more dangerous than one that errors.

Churn-resistance matters more than novelty. I add something to this list when it solves a real problem I had before, not when it trends on Hacker News. Most of the CLI tools here were added in a single deliberate rollout after auditing actual bottlenecks — not accumulated one-by-one over years of reading newsletters.

AI pair-programming is default-on. Claude Code CLI is open for most coding sessions. The agent context window and file access make it genuinely useful for the kind of multi-file, multi-layer changes that used to require a whiteboard. The key shift is treating it as a pair-programmer with a persistent codebase understanding, not a code-completion widget.

The Rust/Python/TypeScript split is intentional. Rust owns anything where correctness and performance matter at the boundary — APIs, WASM, CLI tools with production impact. Python owns data pipelines and strategy code where the ecosystem is the right fit. TypeScript owns the frontend where type-checked component boundaries prevent the class of silent runtime failures that make JavaScript codebases hard to maintain at scale.