Articles

Working Behind Zscaler, Part 3. You taught every tool on your laptop to trust the corporate root — and then `docker build` dies at the first npm install on the same machine, because a container is a fresh machine that never got the memo. So is a WSL distro. So is a CI runner. The host fix doesn't propagate: you didn't fix trust, you fixed one machine's trust. A tour of the rooms on the wrong side of that line — Docker build-time, multi-stage and distroless, WSL2 and its clock-skew gotcha, the CI egress asymmetry — and the one idea that fixes all of them.

Working Behind Zscaler, Part 2. The field guide for your host machine — one repeating pattern instead of a dozen fixes to memorize. Every tool ships its own trust store, so every cert error is one of three moves: point the tool at the OS store, hand it the corporate root as a .pem, or set the proxy vars. Worked across curl, git, npm (NODE_EXTRA_CA_CERTS), pip (REQUESTS_CA_BUNDLE), .NET, and the Azure CLI — the Microsoft tool that ignores your OS trust store even on Windows — plus why the one-line shortcut that disables verification is the wrong fix.

Working Behind Zscaler, Part 1. Your corporate laptop trusts a man-in-the-middle on purpose — and that single fact explains why the browser loads every site fine while npm, pip, and git throw certificate errors on the same machine, same network, same second. A concept-first tour of what Zscaler actually does: TLS inspection, the trust store your browser reads and your tools don't, and why 'it's Zscaler' is the wrong thing to blame.

Fundamentals First, Part 7 — the capstone. Six posts, six fundamentals, and the same quiet move at the end of each one: I kept it in a skill. On why almost none of the leverage in these codebases is mine, the skills pulled straight off one public shelf against the single one I wrote by hand, and the last fundamental — knowing which judgment to encode yourself and which to borrow.

Fundamentals First, Part 6. When the feedback loops finally work, the AI ships faster than you can read — and the bottleneck slides off the machine onto the one thing that can't scale: your head. On the working-memory ceiling, the gray box that saved my brain, the tinkforge Split module I stopped reading, and why the door is a convention held by tests, not a fence held by the compiler.

Fundamentals First, Part 5. The AI builds the right thing and it still doesn't work — because it does too much before it checks. On the rate of feedback as your speed limit, separating the loops by latency, the tdd skill, and the archive change that inverted this blog's own test suite.

Fundamentals First, Part 4. The AI steps into your codebase with no memory and sees a web of modules that can all import each other — not the map you hold in your head. On Ousterhout's deep modules, the codebase-design / design-an-interface skills, and a .NET orchestration stack collapsed behind one door.

Fundamentals First, Part 3. The AI keeps re-explaining your own domain back to you, and the good words you finally agree on evaporate when the session ends. On Eric Evans's ubiquitous language, the domain-modeling skill, and tinkforge's CONTEXT.md — the glossary that stops the AI from talking past you, and from building things that shouldn't exist.

Fundamentals First, Part 2. The AI keeps building something other than what you pictured — because no one, you included, knows exactly what they want until they're made to say it. On Matt Pocock's grill-me skill, Fred Brooks's design concept, and earning a shared picture before you write a line of code.

Opening Fundamentals First — a series on building with AI. The premise: AI didn't make the codebase matter less. It made architecture, domain modeling, and judgment matter more.