Verified Case Studies
Portfolio & Case Studies
Not a link list. The brief, the approach, and what shipped — 10 verified, human-directed case studies across Quantum Computing (4), Generative AI (4), and Agentic AI (2), backed by runtime-verified code.
Comparing Quantum Programming Frameworks: IBM Qiskit, Microsoft Q#, and Quantinuum’s New Stack
A side-by-side technical comparison of IBM Qiskit, Microsoft Q#, and Quantinuum's new stack implementing the Variational Quantum Eigensolver (VQE) for the hydrogen molecule.
- Implemented the Variational Quantum Eigensolver (VQE) for the H2 ground state energy across IBM Qiskit, Microsoft Q#, and Quantinuum's new stack to contrast developer ergonomics and execution models.
- Built parameterized ansatz circuits, Hamiltonian qubit operator mappings (Jordan-Wigner), and classical optimizer loops (COBYLA/SPSA) in Qiskit.
- Developed equivalent Q# operations utilizing the Microsoft Quantum Development Kit to evaluate type safety, operation scoping, and qubit allocation workflows.
- Benchmarked Quantinuum's Guppy, Selene, and Helios stack with TKET compilation pipelines, analyzing gate reduction passes, circuit depth, and statevector fidelity.
A 3,500-word comparative guide featuring complete VQE code listings, circuit compilation metrics, and framework decision criteria for quantum developers.
Quantum Computing Fundamentals Part I: 10 Easy Pieces
A step-by-step introduction designed to demystify quantum mechanics for engineers, bridging linear algebra concepts to executable quantum circuits with clear visual intuition.
- Formulated qubits vs classical bits, state superposition (α|0⟩ + β|1⟩), Bloch sphere vector coordinates (θ, φ), and wavefunction collapse under projective measurement.
- Implemented maximally entangled 2-qubit Bell states (|Φ+⟩, |Ψ+⟩) using Hadamard and CNOT gates with Qiskit Aer statevector simulators.
- Demonstrated reversible quantum logic, unitary transformations, Pauli gates (X, Y, Z), phase gates (S, T), and the quantum no-cloning theorem with standalone Python scripts.
- Illustrated tensor product state spaces, matrix representations, and quantum phase kickback dynamics with structured visual diagrams.
- Delivered an open GitHub repository featuring automated documentation and pytest verification test suites validating circuit probabilities.
A 4,200-word comprehensive learning path featuring 10 standalone, executable Python Qiskit 1.x scripts running on local Aer simulators.
Quantum Computing Fundamentals Part II: 10 Not-So Easy Pieces
An advanced walkthrough taking developers beyond introductory gates into full-scale quantum algorithms, featuring mathematical derivations, circuit schematics, and simulation proofs.
- Built an end-to-end Qiskit implementation of Shor’s algorithm factoring N=15, detailing modular exponentiation (ax mod N), period-finding subroutines, and continuous fraction expansions.
- Constructed multi-qubit Quantum Fourier Transform (QFT) and Quantum Phase Estimation (QPE) circuits to verify unitary eigenvalue extraction via phase kickback.
- Simulated two-qubit Hamiltonians (XX + ZZ interaction terms) using NumPyMinimumEigensolver and Suzuki-Trotter product formulas for molecular ground state energy calculation (-2.0000 Hartree).
- Explored Quantum Teleportation protocols, Superdense Coding, and Grover’s quantum search algorithm with quadratic speedup demonstrations.
A 4,500-word advanced reference with production-grade Qiskit Python scripts for industry-standard NISQ and fault-tolerant algorithms.
How Quantum Computers Threaten Bitcoin and the Entire Internet: Simply Explained
A technical evaluation of the post-quantum vulnerability horizon for asymmetric encryption (RSA-2048, ECDSA secp256k1), quantifying qubit thresholds and evaluating NIST post-quantum migration standards.
- Deconstructed Shor's polynomial-time period-finding algorithm, showing how it reduces discrete logarithms over elliptic curves and prime factorization to polynomial time (O((log N)3)).
- Quantified physical and logical qubit thresholds required to compromise modern cryptography: ~2,048 logical qubits for RSA-2048 in 8 hours, and 4,098–10,000 logical qubits for Bitcoin addresses with exposed public keys.
- Analyzed the "Store Now, Decrypt Later" (SNDL) espionage threat where encrypted state and financial transmissions are harvested today for retroactive quantum decryption.
- Evaluated NIST-standardized Post-Quantum Cryptographic algorithms: ML-KEM (CRYSTALS-Kyber) for key encapsulation, ML-DSA (CRYSTALS-Dilithium) and SLH-DSA (SPHINCS+) for digital signatures, and stateful hash-based alternatives.
A 3,200-word post-quantum readiness roadmap detailing hybrid classical-PQC architectures, crypto-agility frameworks, and Bitcoin soft-fork upgrade proposals.
How to Run Your Own Local LLM — 2026 Edition — Version 1
A production-focused blueprint for deploying, quantizing, and serving high-parameter open-weight LLMs offline with zero telemetry and deterministic latency.
- Benchmarked frontier open-weight LLMs (DeepSeek V3.2, Qwen3.5 397B/122B, MiniMax M2.5, GLM-5/4.7, Kimi-K2.5, GPT-OSS-120B, and Qwen3.5-27B) across memory capacity and token generation speeds.
- Analyzed enterprise and prosumer hardware configurations, detailing unified memory architectures: 4x GB10 Grace Blackwell with 512GB LPDDR5x, 4 PFLOPS FP4 compute, and 200 GbE RoCE interconnects.
- Evaluated Mixture-of-Experts (MoE) routing, Gated Delta Networks, and 4-bit/8-bit quantization profiles (GGUF, AWQ, EXL2) for perplexity degradation and VRAM sizing.
- Provided reproducible installation workflows for Ollama, LM Studio, llama.cpp, and vLLM server backends with OpenAI-compatible API endpoints.
A 3,800-word deployment handbook featuring complete VRAM allocation formulas, hardware buyer decision trees, multi-GPU topology configurations, and runtime benchmarks.
Google Gemini vs Anthropic Claude vs OpenAI ChatGPT vs xAI Grok: The Ultimate Comparison
A data-backed comparative analysis synthesizing frontier model benchmarks, API pricing models, context window architectures, and enterprise adoption tradeoffs.
- Evaluated Google Gemini 3.1 Pro/Flash on DeepThink multi-hypothesis reasoning, 2M+ multimodal context processing, and native Google Workspace RAG integration.
- Analyzed Anthropic Claude 4.6 (Sonnet & Opus) on SWE-bench coding benchmarks, system prompt steering, ad-free enterprise privacy guarantees, and Claude Marketplace tool ecosystems.
- Tested OpenAI ChatGPT with GPT-5.4 Thinking, examining native Computer Use capabilities, autonomous reasoning traces, and API enterprise compliance.
- Investigated xAI Grok 4/5 utilizing real-time X data firehoses, Colossus supercluster training infrastructure, and multi-modal telemetry integration.
- Scored each ecosystem across 6 quantitative dimensions: code generation, mathematical reasoning, long-context retrieval, instruction following, latency, and cost per million tokens.
A 5,000-word multi-vendor decision matrix declaring clear enterprise category winners for software engineering, autonomous agents, document analysis, and real-time intelligence.
The Hidden Geometry of Generative AI: How Manifold Theory Explains the Mysteries Nobody Explained to You
A dual-layer technical explainer (conceptual intuition plus differential geometry) proving how data distributions concentrate on low-dimensional submanifolds embedded within high-dimensional ambient spaces, unifying the mathematical mechanics of modern generative models.
- Formulated the Manifold Hypothesis: real-world data (images, text, audio) concentrates near low-dimensional non-linear submanifolds embedded within massive ambient Euclidean spaces (ℝD).
- Solved the diffusion paradox: proved forward Gaussian diffusion expands data off singular low-dimensional manifolds into ambient space, providing non-zero density everywhere so score matching (∇ log p(x)) can guide denoising paths back to the true manifold.
- Diagnosed GAN instability and mode collapse as support mismatch: disjoint low-dimensional submanifolds yield zero overlap and uninformative Jensen-Shannon divergence gradients.
- Analyzed high-dimensional geometry and measure concentration: demonstrated why latent spaces act as razor-thin spherical shells ("soap bubbles"), necessitating Spherical Linear Interpolation (slerp).
- Explained word vector arithmetic (King − Man + Woman ≈ Queen) as parallel transport along curved tangent bundles on Riemannian manifolds, and adversarial vulnerabilities as imperceptible orthogonal perturbations off the data manifold.
- Deconstructed Flow Matching and Continuous Normalizing Flows (CNFs) as optimal transport vector fields that replace curved diffusion trajectories with straight-line ODE geodesics.
A 9,100-word foundational reference featuring 7 standalone case studies, visual topological diagrams, and mathematical proofs bridging differential geometry to frontier generative models.
Nobody Knows How LLMs Work – Unless You Look at Them as Non-Linear Dynamical Systems
An investigation into the unexplained black-box mysteries of LLMs—why arithmetic capabilities emerge in sudden jumps, why models "grok" generalize thousands of steps after memorization, and why reasoning chains are fragile—explained through nonlinear physics rather than software abstractions.
- Reframed the transformer residual stream forward pass as a discretized continuous Ordinary Differential Equation (ODE) flow, where layer updates represent Euler integration steps along semantic trajectories in state space.
- Analyzed capability emergence as physical first-order and second-order phase transitions, demonstrating why scaling parameters triggers abrupt macroscopic order analogous to water freezing into ice.
- Deconstructed "grokking" as an energy landscape transition: weight decay regularizers penalize high-norm memorization valleys, forcing model weights through saddle points into flat, highly generalizable modular Fourier attractors.
- Demonstrated why long Chain-of-Thought (CoT) reasoning acts as a chaotic trajectory sensitive to initial perturbations (the butterfly effect), where tiny early token drift exponentially diverges downstream conclusions.
- Evaluated the "Edge of Chaos" hypothesis in deep networks: showed how residual connections and LayerNorm tune the maximum Lyapunov exponent near zero (λ ≈ 0), balancing stable information propagation with expressive computational capacity.
A 4,500-word mathematical treatise with quantitative metrics, dynamical phase diagrams, and theoretical proofs connecting statistical mechanics, chaos theory, and deep learning cognition.
The OpenClaw Saga: How the Last Two Weeks Changed the Agentic AI World Forever
A rapid-turnaround architectural analysis of the open-source agentic movement sparked by OpenClaw, evaluating the technical shift from vendor-locked cloud agents to self-hosted, modular agent swarms.
- Deconstructed OpenClaw's autonomous execution architecture: model-agnostic LLM backends, long-running state loops, persistent vector RAG memory, and dynamic tool-calling reflection cycles.
- Mapped the ecosystem explosion: ClawRouter (cost middleware), PicoClaw (10MB lightweight port for $10 Pi Zero), IronClaw (Rust/WASM), and ClawBands (sudo approval layer).
- Analyzed severe security vulnerabilities including CVE-2026-25253 (WebSocket origin header bypass) and exposed internet-facing gateway instances.
- Evaluated the economic disruption of local edge-orchestrated agents displacing centralized enterprise cloud API subscriptions.
A 3,600-word architectural and security report explaining how edge-based local agents disrupt big tech cloud API monopolies with hardened deployment recommendations.
Hermes Agent vs OpenClaw: Which AI Agent Framework Wins in 2026?
An in-depth architectural comparison of open agent execution environments, comparing Hermes Agent's trajectory optimization with OpenClaw's self-improving framework.
- Evaluated Hermes Agent (inference-time reasoning, tool-use, trajectory optimization) against OpenClaw (self-improving agent framework and skill accretion).
- Analyzed the security risk models of agentic loop execution (arbitrary shell execution, sandbox escapes, credential exposure).
- Compared execution runtimes (Tinker-Atropos GRPO reinforcement learning pipelines vs Node.js Gateway) and sandbox backends (Docker, Modal, Daytona, SSH, Singularity).
- Deconstructed USER.md workspace memory persistence and autonomous local skill generation mechanics.
A 4,000-word deep architectural breakdown comparing state-of-the-art open agent frameworks, trajectory search algorithms, and runtime sandbox isolation.
Need Something Like This Written?
AI-assisted, human-directed documentation, deep dives, courses, and quantum content — backed by runtime-verified code in Python and Rust.