HarrisonSec — Long-form writing on agent runtimes, distributed systems, and security

This is Part 1 of our Claude Code Architecture Deep Dive series.

The longest cut of the AI Stack material.

Same first-principles framework as the 15-minute video — LLM talks, program walks — but with deeper exploration of each layer and the seams between them.

Episode Summary This is the extended version of Episode 1.

Episode Summary LLM.

LLM, Token, Agent — They're All the Same Thing.

There’s an impulse, when someone first learns about consistency models in distributed systems, to want to classify the taxonomy into neat drawers.

LLM.

gRPC interceptors are the middleware pattern, specialized for gRPC.

Go 1.18 shipped generics in March 2022.

Go’s performance culture has a ritual quality.

sync.Pool is one of those Go features that shows up prominently in “how to write fast Go” blog posts and then gets applied to everything.

It’s 2 AM.

Episode Summary Fail fast is widely accepted as a best practice in software engineering.

A team I worked with once migrated an order-placement path from gRPC to NATS because “it’s decoupled and faster.”

The number of times I’ve watched a team pick a message system based on “Company X uses it” is depressing.

“A Docker container is basically a lightweight VM, right?”

I worked with a team that rewrote a critical service from Go to Rust because “performance.”

I’ve reviewed enough Go backend test suites to notice a pattern.

A team I worked with tried to build their billing system on top of their tracing pipeline.

The bug was alive for three weeks.

For a while, I thought channels were Go’s way of doing message passing.

In the last post I walked through the four concurrency pillars — shared memory + locks, CSP, actors, STM — and argued that real systems mix them on purpose.

Most working engineers have spent ninety percent of their concurrent-programming life in one model: shared memory protected by locks.

Somewhere around 40,000 concurrent connections, your Java service falls over.

The single most consequential transition in x86: 16-bit real mode → 32-bit protected mode.

The full pipeline for someone who wants to debug ARM64 kernel code without sinking weeks into toolchain setup: Yocto for the build, QEMU as the target, GDB attached over the QEMU GDB stub.

A walkthrough of SentinelEdge — the project where I bring eBPF, kernel-level tracing, and production-style observability together into one framework.

Two languages, same hardware, different machine code.

Two ways to attach an eBPF program to a kernel function: kprobe (old, INT3-based, more overhead) and fentry (newer, BPF trampoline, lower overhead).

Same C code, two architectures, two different observable behaviors. x86-64’s TSO model hides store→load reordering most of the time; ARM64’s weaker model lets you see it directly.

Same code, different cache layout, 10× performance gap.

The x86_64 counterpart to the ARM64 walkthrough.

When CS changes mid-execution — for example, a far jump from your bootloader’s load address into your second-stage code — GDB’s symbol resolution silently breaks.

Real reverse engineers know: every x86 conditional jump is decided by EFLAGS bits — ZF, SF, CF, OF — not by what your source code looked like.

🦀 Rust vs C Assembly Performance Analysis: Panic or Segfault?

This is not GRUB.

Legacy Compatibility Lab: My Full Stack for Reviving Dead Software “Fix software that shouldn’t be running anymore — and make it run again.”

Placed 2nd at BSides Vancouver 2025 Blue Team CTF – With Just ChatGPT and Stubbornness Summary I placed 2nd at the BSides Vancouver 2025 Blue Team CTF using nothing but ChatGPT and sheer persistence.

About This Video In this lab tour, I share my personal journey through computing history and security evolution.

Secured VLAN: Enterprise-Grade Network Segmentation & Security 1.

Video Presentation Why This Video is Worth Your Time This extensive tutorial presents a complete enterprise network security design and implementation using Cisco Packet Tracer.

Why This Video Is Worth Watching This is one of the clearest and most intuitive explanations of buffer overflow attacks I’ve seen.

StegoSafe: Securing Your Bitcoin Keys Using Advanced Steganography Executive Summary StegoSafe represents a breakthrough in digital asset security, combining ancient steganographic principles with cutting-edge cryptography to create an innovative solution…

LegacyOps™ — Fixing What Others Fear to Touch Legacy systems are everywhere.

QuantumVault: A Bootloader-Level Demo of Cold Storage Control 1.