Architecture & Techniques

Project: cochranblock · Date: April 8, 2026 · Commit: 11c115f

GPU-zero-cost animated starfield using a static CSS mask with punched-out star holes over a screen-sized background-position loop. Standard approach: oversized element (200% viewport) with transform: translate3d — allocates 4x GPU memory. Fish Tank approach: element is 100% viewport, gradient is larger via background-size: 200%, animation is background-position only — compositor-only, no GPU texture reallocation.

Result: 72fps, 0.0000 CLS, 176ms first paint. Works on every Android phone. 1/4 the GPU memory.

Origin: Scrolling fish tank decoration from an Arizona garage sale, circa 2006-2010.

Project: kova · Date: March 2026

Every function, type, and field in the codebase is tokenized to a compressed identifier: f0-fN (functions), t0-tN (types), s0-sN (fields). AI context consumption drops 75% — local models with 8K context windows can do work that previously required 100K+ cloud models. 368/368 symbols compressed in production.

Why it's novel: Codebases are compressed for humans (short names) or machines (minification). Nobody tokenizes for AI context budget. This is a new axis of compression.

Project: pixel-forge · Date: April 2026

36-byte BLAKE3 signature embedded in every AI model file (.safetensors). Verified at load time before any inference. Unsigned or tampered models are rejected. The signature travels with the file — no certificate authority, no network call, no infrastructure.

Why it's novel: Model signing exists (Sigstore, Notary). But those require infrastructure — registries, certificate chains, network access. NanoSign is 36 bytes appended to the file. Verify with one hash. Works air-gapped.

Project: kova / tmuxisfree · Date: April 2026

Rate-limit-aware broadcast across 28 concurrent AI agent sessions. Fast first pass sends to all panes. Collect failures (rate-limited panes). Retry with exponential backoff (10s, 20s, 30s, 40s, 50s). The mesh absorbs rate limits like a sponge — soaks up the failures and wrings them out on retry.

Why it's novel: Load balancers retry failed requests. But this retries failed AI agent dispatches across a tmux fleet with per-pane cooldowns and rate-limit detection via string matching on pane output. Nobody orchestrates AI agents through tmux panes with a retry mesh.

Project: entire portfolio · Date: 2026

One Rust binary embeds HTTP server, database (sled), routing, templates, static assets, compression, and TLS config. Deploy is a streaming pipe: ssh bt 'cat binary' | ssh gd 'cat > .new && mv .new binary'. No container, no orchestrator, no config file, no asset directory. The binary IS the infrastructure.

Prior art: Single binaries exist (Caddy, BusyBox). Pipe deploys are Unix fundamentals. The architecture is the combination: binary with everything embedded + streaming pipe deploy + self-managing PID relay + zero external dependencies. We haven't found this exact stack elsewhere.

Project: rogue-repo · Date: March 2026

Zero-downtime binary self-replacement. New binary starts, reads old PID from lockfile, sends SIGTERM to old process, binds the port via SO_REUSEPORT, writes its own PID. The old process dies gracefully. The new one takes over. No service manager, no systemctl, no container orchestration.

Prior art: Unicorn (Ruby, 2009) does PID relay. Nginx does master-worker handoff. What's different: those need an external supervisor. This binary manages its own lifecycle — the binary IS the supervisor.

Named after: the 2019 film Gemini Man.

Project: entire portfolio · Date: April 2026

A development architecture where each cycle reduces external AI dependency. Stage 1: development-only scaffolding against unverified models (never in production path). Stage 2: tools run locally against signed, verified models only. Stage 3: system trains on its own data. Stage 4: system tests itself. Stage 5: system deploys itself. Stage 6: system discovers its own work. Production inference paths accept signed models only — the development scaffolding is dismantled before any shipping binary is cut.

Prior art: Self-improving AI is a research concept. What's different: a concrete 6-stage convergence with working code at each stage, not a paper. Named ratchets (techniques that permanently reduce dependency) with commit-level provenance.

Current stage: 2 of 6. Stages 3-6 partially implemented.

Project: every repo · Date: April 2026 · Canonical template: MOONSHOT_FRAME.md

A review protocol applied before every merge, push, and deploy. Asks one question: "If this code / pitch / document were the foundation of a civilizational-scale outcome, would it still hold up?" The target outcome shifts with context (spacecraft, FCA audit, hostile evaluator, forensic investigator), but the five forces are universal: typed where possible, bounded where unbounded, observable where silent, explainable where obvious, reviewer-friendly where shortcut-friendly.

In action: Openbooks JSON parser v1 (string split on "date":", silent failures, no pagination) failed Moonshot Frame. v2 (typed GhCommitEnvelope / GhCommit / GhSignature, typed FetchError, RFC 5988 Link pagination, 20-page safety cap, committer.date not backdate-able, visible errors via eprintln) passed. Same pattern applies to any wire format: telemetry, safetensors, CCSDS frames, AI tool calls.

Prior art: Code review checklists exist. DO-178C review criteria exist. Aerospace and automotive qualification processes exist. What's different: a single-question frame that scales from a one-line commit to a twenty-page proposal, with deterministic trigger ("good enough for me" is the trigger to apply), public template, and a shield badge repos can earn. Pairs with NanoSign + Timeline of Invention as the Cochran Block quality stack.

Apply when: the current version feels "good enough for me." That phrase is the trigger. Apply double under time pressure — that's when regret compounds.

Project: every Rust repo · Date: April 2026 · Profile template: diamond-profile.toml

Carbon + sustained pressure + geologic time = diamond. Code + sustained compiler pressure + release discipline = diamond binary. Every build is a compression opportunity. Every release is another pressure pass. A binary that stops shrinking has stopped learning. A binary that grows without justification failed a merge.

Two profiles, one discipline. P27 ships in two variants because a laptop binary serving requests has a different pressure target than a CubeSat binary flying on-orbit.

[profile.diamond] — speed-Diamond for laptops, servers, request-serving binaries: opt-level=3, lto="fat", codegen-units=1, strip=true, panic="abort", overflow-checks=false, debug=false, incremental=false. Binary grows 10-30%, hot paths run 15-30% faster. Build: cargo build --profile=diamond.

[profile.diamond-edge] — size-Diamond for phones, edge compute, LoRa mesh nodes, embedded, spacecraft, on-device AI: same settings except opt-level="s". Binary shrinks 10-25%, hot paths slightly slower (still fast because LTO is still fat). Build: cargo build --profile=diamond-edge.

Rule of thumb: if the binary ships to more than ~10 machines, lean size-Diamond. If it serves more than ~10 req/sec on a single machine, lean speed-Diamond. Optional post-build: upx --best --lzma for 50-70% more compression on binaries destined for non-AV-scanned distribution.

Geology of the stack:

• Interpreted scripts → wood (flammable, bulky)
• C/C++ with runtime deps → coal (burns hot, cracks under load)
• Containerized stacks → sandbags piled up (looks solid, falls over)
• Bare Rust binaries → graphite (cleaner than coal, still soft)
• Rust + P27 discipline → diamond (crystalline, dense, sealed)

Geology report per release: record binary size to binary-sizes.log every release. Binary should shrink or stay flat over cycles. Growth requires justification. The log IS the pressure curve.

Prior art: binary-size optimization is a decades-old concern (1980s embedded systems, demoscene 4K/64K intros, BusyBox, sqlite single-file amalgamation). What's different: a named Rust-specific discipline, continuous rather than one-shot, with a geology metaphor that maps carbon-to-diamond onto Rust's compilation pipeline, a shipped profile template anyone can paste, and a shield repos earn by proving the geology log.

Does not collide with Caltagirone's Diamond Model of Intrusion Analysis (2013) — his Diamond is about how attacks work (Adversary / Capability / Infrastructure / Victim). Ours is about how binaries compress. Different domains, both happen to use the word.

Project: exopack · Date: March 2026

Run the full test suite 3 times. All 3 must produce identical results. Not "it passed" — "it passed identically three times." Catches flaky tests, race conditions, non-deterministic behavior, and timing-dependent bugs that pass once but fail under load.

Prior art: Flaky test detection exists. Running tests N times exists. What's different: triple-deterministic as a hard merge gate, not a diagnostic. If it can't pass 3 times identically, it doesn't merge.

Deployed: 6+ production projects via exopack test augmentation.

Project: pixel-forge

Three diffusion models at increasing fidelity. Cinder (1.09M params) runs on anything. Quench (5.83M) needs a GPU. Anvil (16.9M) needs a good GPU. Mixture-of-Experts routing picks the right model for available hardware. Original application of MoE to tiered pixel art diffusion.

Project: kova

LLM calls 13 tools (read/write/edit/bash/glob/grep/review) in an autonomous loop until the task is done. At 80% context budget, the agent summarizes its own prior work to free tokens. The compaction is LLM-powered, not truncation — key decisions survive.

Project: approuter

One reverse proxy API that abstracts Cloudflare Tunnels, ngrok, Tailscale Funnel, Bore, and localtunnel. Swap tunnel providers without changing application code. Adapter pattern applied to tunnel infrastructure.

Project: kova

Distributed build/test/deploy across 4 worker nodes via SSH with tokenized command protocol (c1-c9 for node ops, x0-x9 for cargo, g0-g9 for git). Nodes work in parallel, output streams with per-node prefix. Military C2 concepts applied to software development.