Microsoft Agent Framework Go — Every Lesson
A lesson-by-lesson course through the Microsoft Agent Framework Go: agents, tools, workflows, memory, and production patterns, each with runnable Go code.
Course Series
Deep, structured series that take a topic from first principles to production — 91 series, 886 lessons in total. Each one is a self-contained curriculum you can work through in order.
Rust from the Ground Up
An original Rust curriculum, from first principles — Module 1 foundations (why Rust, Cargo, types/immutability, the ownership trio, structs/enums/pattern matching, error handling), Module 2 (collections, generics, traits, closures, iterators, smart pointers, modules), Module 3 (fearless concurrency with threads/Arc/Mutex/Send/Sync/channels, async/await, testing, ergonomic error handling with anyhow/thiserror, and macros), and Module 4 (advanced traits and types, unsafe Rust, FFI, closures/function pointers, building a real CLI application, the crate ecosystem and tooling, and performance/idioms). The Rust companion to the Go and Python curricula.
Google ADK, Concept by Concept
Google's Agent Development Kit explained one concept at a time — agents, tools, sessions, artifacts, and orchestration, with concrete examples.
Road Go Ever On
An original Go-language curriculum, from fundamentals through concurrency, tooling, and idiomatic production Go.
AI Engineering in Go
Building AI systems from scratch in Go — embeddings, retrieval, prompting, evaluation, and serving — without hiding behind a framework.
Agentic Commerce
How AI agents pay: the emerging protocols (ACP, AP2, x402), agent identity and verifiable mandates, checkout and card-network flows, fraud and disputes, and how merchants become agent-ready.
Learning the Microsoft Agent Framework — Go
A guided introduction to the Microsoft Agent Framework in Go, building up the core concepts one focused lesson at a time.
Learning the Microsoft Agent Framework — Python
A guided introduction to the Microsoft Agent Framework in Python, building up the core concepts one focused lesson at a time.
The AI Production Roadmap
Taking AI from prototype to durable production as a composed, governed system — strategy and ownership, governance, data foundations, building the system, evaluation, deployment, MLOps/LLMOps, security, observability, responsible AI, cost, and platformization.
LangGraph, Concept by Concept
LangGraph explained one concept at a time — state, nodes, edges, checkpointing, and human-in-the-loop — for building reliable stateful agent graphs.
ADK to Microsoft Agent Framework Migration
A practical migration path from Google's Agent Development Kit to the Microsoft Agent Framework — concept mapping, code translation, and the gotchas that bite.
Agent2Agent Protocol from Scratch
The A2A protocol end to end — Agent Cards and discovery, the task lifecycle, the message/part/artifact content model, transports and methods, streaming and push notifications, security, and how A2A and MCP compose.
Agentic RAG
Making retrieval reason — why naive RAG falls short, query transformation, routing and retrieval as a tool, self-correcting retrieval, multi-hop iteration, evaluation, and building an agentic RAG system that escalates cost only when a question needs it.
AI Agent Design Patterns
A framework-agnostic guide to the recurring patterns for building LLM agents — what an agent is (the model directs the flow; agents vs workflows), the core reason-act-observe loop (ReAct), tool use, planning and decomposition, memory (short-term vs long-term), reflection and self-correction (Reflexion), multi-agent patterns, and building reliable agents (and when not to use agents at all).
AI Cost Optimization
Controlling the cost of AI systems end to end — the token economy, model selection and routing, prompt and context optimization, caching, batching, RAG/fine-tuning/self-hosting trade-offs, and cost observability and AI FinOps.
AI Evaluation and Benchmarking
How to measure LLM quality rigorously — why evaluation is the real bottleneck in shipping AI (turning "seems better" into a number), a taxonomy of metrics (exact/structural match, reference overlap like BLEU/ROUGE, semantic similarity, task-specific/functional), LLM-as-a-judge (pairwise vs pointwise, position/verbosity/self-preference biases, calibrating the judge against humans), building an eval harness (dataset, runner, scorers, report, golden sets, CI gating), how public benchmarks are designed and read critically (MMLU/HELM/BIG-bench, construct validity, saturation), contamination and Goodhart's law (held-out/private sets, dev/test splits), human evaluation and preference (inter-annotator agreement, arenas/Elo, RLHF), and evaluation in production (A/B tests, guardrail metrics, drift monitoring, the continuous loop).
AI for the Energy Sector
How AI helps operate a decarbonizing electrical grid — why AI matters for the grid (rising complexity, real-time balancing), understanding the grid (generation/transmission/distribution, frequency, physical constraints), forecasting demand and variable renewable generation, balancing supply and demand (dispatch/optimization), the renewable integration challenge, demand-side flexibility (demand response, DERs, virtual power plants), grid reliability and assets (predictive maintenance, anomaly detection), and the future plus responsible AI for safety-critical infrastructure.
AI Gateways and LLM Infrastructure
The control plane for model calls — why you need an AI gateway (the API-gateway pattern for LLMs: one choke point between apps and every provider), the unified API (one interface, gateway translates to each provider, decoupling apps from vendors so model-swapping is a config change), routing and load balancing (route by cost/capability/policy, spread load across providers and keys, LLM token-based limits), reliability (retries with backoff, transparent fallback across providers, circuit breakers, the gateway's own HA), caching (exact + semantic caching to cut cost and latency; when not to cache), rate limiting/quotas/budgets (enforced spend control and per-team chargeback), observability and governance (cost metering, tracing, guardrails, access control, audit — enforced centrally), and building/operating (build vs adopt vs buy, running it as critical infrastructure). Includes interactive archify architecture and request-flow diagrams. Grounded in LiteLLM, API-gateway/circuit-breaker patterns, OpenTelemetry.
AI Governance for Engineers
AI governance made concrete for engineers — the NIST AI RMF, EU AI Act, ISO/IEC 42001, and how to build them into the SDLC.
AI Red Teaming
Red-teaming AI systems — adversarial testing, jailbreaks, attack taxonomies, and how to probe models and agents before attackers do.
AI Security Engineering
Securing AI systems in production — the OWASP LLM Top 10, MITRE ATLAS, prompt injection, data exfiltration, and defensive engineering.
Amazon Bedrock in Go
Using Amazon Bedrock from Go with the AWS SDK for Go v2 — models, tool use, streaming, embeddings, and guardrails.
API Design
Designing APIs people love to use — resource modeling, versioning, pagination, errors, and the conventions that age well.
API Security
Securing APIs end to end — authentication, authorization, rate limiting, input validation, and the OWASP API risks that matter most.
Business Finance for Engineers
Financial literacy for technical people — why finance matters, the three statements (income statement/P&L, balance sheet, cash flow), the crucial profit-vs-cash distinction, unit economics (contribution margin, CAC/LTV), SaaS/recurring-revenue metrics (MRR/ARR, churn, NRR, Rule of 40), budgeting and forecasting, and reading financial health to make better decisions.
C from the Ground Up
C for programmers who want to understand how computers actually work — why C and its four-stage compilation model (preprocess, compile, assemble, link; declarations vs definitions), types/variables/operators (fixed-width integers, signedness hazards, integer promotion, bitwise ops), control flow and functions (pass-by-value, the call stack, scope and lifetime), pointers (addresses, dereference, pointer arithmetic, NULL, pointer-to-pointer — the heart of C), arrays/strings/memory-layout (array-to-pointer decay, null-terminated strings, buffer overflows), dynamic memory management (stack vs heap, malloc/calloc/realloc/free, ownership, leaks/use-after-free/double-free, Valgrind), structs/unions/data-structures (typedef, padding, tagged unions, building a linked list), and the preprocessor, undefined behavior, and safe-C idioms. Rounds out the language-series set alongside Go, Python, Rust, and TypeScript.
Caching Systems
How caching makes systems fast — why caching exists (locality, the memory-hierarchy principle), caching fundamentals (hits, misses, hit rate, what to cache), eviction policies (LRU/LFU/FIFO/TTL), the hard problem of cache invalidation (staleness, TTL vs explicit), caching patterns (cache-aside, write-through/back/around), distributed caching (Redis/Memcached, sharding, consistent hashing), web and CDN caching, and caching pitfalls (stampede, penetration, cold cache) and practice.
CI/CD Pipelines from First Principles
CI/CD from first principles, tool-agnostic — what CI/CD is and why (integration hell, deployment fear, the pipeline, DORA), Continuous Integration in depth (a practice not a server: merge small/often, trunk-based, keep the mainline green), the build and test stages (test pyramid, deterministic/isolated tests, fail-fast staging, build-once-promote, caching/parallelism), Continuous Delivery vs Deployment (the human-gate distinction, environment promotion, choosing by fit), deployment strategies (blue-green, canary, rolling, feature flags), pipeline as code (declarative workflows/jobs/steps, GitHub Actions, DRY/pinning), security in the pipeline (DevSecOps: least-privilege credentials, secrets, SAST/SCA/DAST, SBOM/signing/SLSA supply-chain integrity), and operating/measuring pipelines (the pipeline as a product, fast recovery, observability, the four DORA metrics).
Claude Code
Working effectively with Claude Code — the agentic, terminal-native coding tool — from mental model to hooks, skills, and real workflows.
Code Review
The craft of code review — what to look for, how to give feedback, and the practices that make review a force multiplier, not a bottleneck.
Computer Networking for Backend Engineers
The network stack for people who build on it — layers and encapsulation, IP and routing, TCP vs UDP, DNS, TLS/HTTPS, HTTP/1.1 to 2 to 3, load balancing and proxies, and the practices that keep networked code resilient.
Context Engineering
The discipline of curating everything a model sees at inference — the token budget, system prompts, retrieval, memory and history, tools and structured data, compaction and long context, and assembling it into a context pipeline.
CrewAI, Concept by Concept
Building role-based multi-agent systems with CrewAI — agents (role, goal, backstory), tasks, crews and process, tools, event-driven Flows, memory and collaboration, and running CrewAI reliably and affordably in production.
Cryptography Engineering
Applied cryptography for engineers who use it rather than invent it — the four guarantees (confidentiality, integrity, authenticity, non-repudiation), symmetric encryption and AEAD, hashing/MACs/password storage, public-key crypto and key exchange, signatures and PKI, TLS, key management, and the misuse pitfalls (randomness, timing, nonce reuse) that silently break sound primitives.
Data Engineering
How raw data becomes usable — what data engineering is (the plumbing beneath all data work), data pipelines and the ETL→ELT shift, where data lives (warehouses, lakes, lakehouses, OLTP vs OLAP), data modeling for analytics (dimensional/star schema), batch vs streaming processing, the modern data stack (cloud, ELT, transformation-in-the-warehouse), data quality and governance (catching silent failures), and data engineering in practice (DataOps, serving analytics and AI).
Database Internals
How databases actually work under the SQL — storage engines (B-tree vs LSM), pages and the buffer pool, the write-ahead log, indexes, transactions and isolation, MVCC, and query planning.
DevSecOps
Security woven into the delivery pipeline — supply-chain integrity, SAST/DAST, secrets, policy-as-code, and shifting security left.
Distributed Systems from First Principles
Distributed systems built up from the ground up — partial failure, consistency models, CAP/PACELC, logical clocks, replication, partitioning, consensus (Raft), and resilience — the concepts behind every large-scale backend.
DSPy, Concept by Concept
Programming language models instead of prompting them — signatures, modules, composed programs, metrics and evaluation, optimizers that compile your prompts, and building RAG and agents in DSPy that improve themselves against a metric.
eBPF from First Principles
eBPF from the ground up — what eBPF is and why it matters (run sandboxed programs safely inside the Linux kernel at runtime, no module or rebuild; kernel power without kernel danger), the kernel/user-space boundary (why extending the kernel used to mean dangerous modules or limited user space, and eBPF as the third option), how eBPF works (programs, hooks, maps, the load path: bytecode → verifier → JIT → attach), the verifier and safety (static analysis proving termination and memory safety before a program runs — the central innovation), eBPF for observability (trace anything the kernel sees, low overhead, no app changes; bcc/bpftrace), eBPF for networking (XDP fast-path packet processing, load balancing, Cilium), eBPF for security (kernel-vantage detection and enforcement, LSM, Falco), and the ecosystem/building with it (CO-RE compile-once-run-everywhere, libbpf, language SDKs, where it is heading). Includes an interactive archify architecture diagram. Grounded in ebpf.io, kernel BPF docs, Brendan Gregg, Cilium, Falco.
Emotional Intelligence for Engineers & Leaders
A practical guide to emotional intelligence for technical people — what EQ is and why it's the ceiling on technical careers, self-awareness, self-regulation (responding vs reacting), motivation and resilience, empathy and active listening, difficult conversations and feedback, influence and social skill, and EQ in leadership and teams (psychological safety) — framed as a learnable skillset, not a fixed trait.
Evaluating Agents in Go
Evaluating AI agents in Go — building the datasets, scorers, and regression harnesses that tell you whether an agent actually works.
Event-Driven Architecture with Kafka
Building event-driven systems on Apache Kafka — why EDA, the log abstraction, producers, consumers and consumer groups, delivery semantics and exactly-once, schemas and event design, the core patterns (event sourcing, CQRS, outbox, saga), and running Kafka in production.
Fine-Tuning LLMs, Concept by Concept
When and how to fine-tune a language model — behavior vs knowledge, the fine-tuning spectrum, LoRA and QLoRA, dataset quality, alignment (RLHF/DPO), rigorous evaluation, and the production lifecycle.
Forward Deployed Engineering
The forward-deployed engineer's playbook — embedding with customers, rapid iteration, and turning field work into durable product.
Git Internals
How Git actually works, from the storage model up — the content-addressed object model (blob/tree/commit/tag named by content hash), refs/HEAD and history as a directed acyclic graph (branches are pointers, reachability is the organizing idea), the index as a real staging-area file (the three trees), merge vs rebase demystified (the merge base, three-way merge, replaying commits), packfiles and delta compression (why snapshot-per-commit stays small), the reflog as a safety net (unreachable is not deleted), remotes/refspecs/fetch/push (collaboration as the same model across repos), and rewriting history safely (the golden rule, force-with-lease, revert for public history).
Go-to-Market Strategy
A practical, engineer's guide to bringing a product to market and turning it into customers — what GTM is and why it matters as much as the product, knowing your market (segmentation, ICP, beachhead), positioning and messaging, GTM motions (product-led vs sales-led vs channel), pricing and packaging, channels and demand generation, launch and adoption (crossing the chasm), and measuring GTM (funnel metrics, CAC/LTV, retention).
gRPC and Protocol Buffers
gRPC from the ground up — why RPC and gRPC (operation-centric calls, HTTP/2 + protobuf + codegen, when to use it over REST), Protocol Buffers as the contract and wire format (the .proto schema, tag-based binary encoding, field-number discipline and safe schema evolution), the four RPC types (unary, server/client/bidirectional streaming and when to use each), code generation and stubs (protoc, the generated client/server boundary, type safety across the network), deadlines/metadata/interceptors (deadline propagation, the metadata side-channel, cross-cutting middleware), error handling (the status-code model, rich error details, retryable vs terminal), streaming and backpressure (flows vs values, HTTP/2 flow control, writing streams that scale), and gRPC in production (request-level load balancing, TLS/auth, gRPC-Web and REST gateways, observability, evolving the contract safely).
Guardrails and Prompt Injection Defense
How to build LLM applications that stay safe despite prompt injection — the defensive companion to red-teaming. Why prompt injection is unsolved (instructions and data share one channel; contain, don't prevent), a taxonomy of attacks (direct vs indirect injection, jailbreaks, the confused-deputy problem), input defenses and their hard limits (structural validation helps; filtering can't — indirect injection bypasses it), prompt hardening (delimiting, spotlighting, instruction hierarchy — probabilistic, not a fence), architecture and least privilege (the load-bearing defense: scoped tools, no privilege inheritance, human-in-the-loop, the dual-LLM pattern), treating model output as untrusted (XSS/SQLi/SSRF/exfiltration via output, context-specific encoding, structured output), guardrails in practice (moderation, injection classifiers, PII detection, layered defense in depth, fail-safe), and evaluating/operating guardrails (red-teaming your own system, production monitoring, NIST AI RMF, the honest state of the art). Grounded in the OWASP LLM Top 10, indirect-injection research, and the dual-LLM pattern.
Harness Engineering in Go
Engineering rigor in Go — testing, benchmarking, profiling, and the harness patterns that keep production Go services honest.
Hiring & People for Engineers and Leaders
A practical guide to hiring and people for engineers and technical leaders — why people are everything (the highest-leverage area), the hiring process (a funnel), interviewing and assessment (structured, bias-aware), onboarding (the neglected step), feedback and performance (growth over judgment, continuous over annual), growth and career development (linked to retention), retention and engagement (why people leave and stay), and building a great team (culture, diversity, people-first leadership).
IBM watsonx in Python
IBM watsonx in Python — the watsonx.ai SDK and LangChain, Granite models, Granite Guardian, and watsonx.governance.
Kubernetes from First Principles
Kubernetes learned from the ground up — the problem it solves (declarative desired state + reconciliation), containers (namespaces/cgroups/images), pods, controllers, services and networking, configuration and state, scheduling and resources, and operators and production.
LangChain, Concept by Concept
The broad, standardizing LLM toolkit concept by concept — what LangChain is (and how it relates to LangGraph), models/prompts/parsers, LCEL and Runnables, chains, retrieval and RAG, tools and agents, memory and state, and production with LangSmith.
Legal & IP Basics for Engineers and Founders
An educational (not legal advice) guide to legal and intellectual-property basics for engineers and founders — why legal literacy matters (and when to get a lawyer), business entities (LLC/corporation, limited liability), the four IP types, copyright and software (code ownership, work-for-hire), patents/trademarks/trade secrets, software licensing and open source (permissive vs copyleft), contracts and agreements (NDAs, IP assignment, terms of service), and privacy/compliance (GDPR).
LlamaIndex, Concept by Concept
LlamaIndex explained one concept at a time — documents and nodes, indexes and embeddings, retrievers, query engines, chat, agents, and workflows — for building data-centric LLM applications from prototype to production.
LLM Inference and Serving
How large language models actually run in production — prefill vs decode, the KV cache, continuous batching, quantization, speculative decoding, serving engines (vLLM/PagedAttention), multi-GPU scaling, and tuning latency, throughput, and cost.
Marketing for Technical Products
Marketing for engineers and technical founders — what marketing honestly is (and why the engineer's disdain is costly), brand and positioning, product marketing (the product-market bridge), content marketing and SEO, demand generation and the funnel, developer marketing (marketing to engineers), growth and growth loops, and measuring marketing (attribution, CAC/LTV, brand vs performance).
Mixture of Experts and Modern LLM Architecture
How frontier LLMs are actually built — the shift from dense to sparse (compute-per-token welded to parameter count in dense models; conditional computation decouples capacity from per-token compute), the transformer backbone recapped (attention mixes information across tokens, the FFN block MoE replaces), Mixture of Experts core idea (many expert FFNs + a router picking top-k per token; total vs active parameters), routing and load balancing (expert collapse, the auxiliary load-balancing loss, expert capacity and token dropping, expert-choice routing), training and serving MoE (the compute-saved-memory-not trade, expert parallelism, all-to-all communication), the long-context problem (attention's quadratic compute vs the KV cache's linear memory), efficient attention (GQA/MQA shrink the KV cache, FlashAttention for fast exact attention, sliding-window/sparse to break the quadratic), and the anatomy of a modern frontier LLM plus where architecture is heading. Grounded in the MoE/Switch/Mixtral papers, Attention Is All You Need, FlashAttention, and GQA.
Model Context Protocol from Scratch
The Model Context Protocol end to end — the spec and mental model, transports, tools/resources/prompts, building a server and a client, and shipping MCP securely to production.
Multimodal AI
How AI works across modalities — what multimodal AI is (beyond text, the shared-representation idea), how models see (CNNs to Vision Transformers), connecting modalities with CLIP and shared embedding spaces, vision-language models (LLMs that see), image generation with diffusion, audio and speech (recognition and synthesis), video and beyond (the temporal frontier), and building with multimodal AI toward the any-to-any future.
NVIDIA AI Stack in Python
The NVIDIA AI stack in Python — NIM microservices, NeMo, and Guardrails — wired together with the OpenAI client and LangChain.
Observability Engineering
Understanding systems you can't see inside — observability vs monitoring, the three pillars (metrics, logs, traces), OpenTelemetry, SLIs/SLOs/error budgets, alerting that respects on-call, and building the practice.
On-Device AI with Gemma and Flutter
Building private, offline-capable AI that runs entirely on the user's phone — the case for on-device AI, edge constraints, quantization, the on-device runtime, running Gemma with flutter_gemma, on-device RAG, privacy-by-architecture, and shipping.
Operating Systems for Engineers
The OS concepts that matter to engineers building on top of it — what an OS does (resource management + abstraction), processes, threads and concurrency, CPU scheduling, virtual memory, the memory hierarchy, I/O models, and why OS knowledge turns production mysteries into diagnosable problems.
Operations & Org Design
How a company runs and structures itself to work effectively, especially at scale — what operations is (the invisible enabler), processes and systems (good process vs bureaucracy), organizational structure (functional/divisional/matrix tradeoffs), org design and Conway's law (org structure shapes what you build), scaling teams and communication overhead, decision-making (decision rights, centralized vs distributed, quality vs speed), organizational culture, and operational excellence.
Platform Engineering
The DevOps-to-platform-engineering arc — from DevOps and its cognitive-load problem through CI/CD, infrastructure as code, and GitOps, to internal developer platforms, golden paths and developer experience, reliability, and building and adopting a platform as a product.
Product Management for Engineers
A practical guide to product management for engineers — what PM actually is (owning the why and what, not the how; myths dispelled), understanding the problem (discovery, problems over solutions), prioritization (the core skill of saying no), product strategy and vision, working with engineering and design (the product trio), metrics and data (measuring real value, data vs judgment), shipping and iterating (MVP, product-market fit), and PM in practice and as a career (including product-minded engineering).
Pydantic AI, Concept by Concept
The type-safe Python agent framework from the Pydantic team, concept by concept — agents, structured outputs, tools, dependency injection, messages and streaming, testing and evals, and production.
Reasoning Models & Test-Time Compute
How modern reasoning models work and how to use them — thinking before answering, chain-of-thought and self-consistency, test-time compute as a new scaling axis, training via RL on verifiable rewards, inference-time techniques (best-of-N, verifiers, search), the economics of thinking tokens, prompting and usage differences, and the limits (faithfulness, diminishing returns, evaluation) and frontier.
Recommender Systems from the Ground Up
Recommender systems from the ground up — the recommendation problem (match people to items from a huge catalog, personally and in real time, from sparse noisy interaction data; explicit vs implicit feedback; scale, personalization, cold start, latency), collaborative filtering (recommend from the behavior of similar users/items using only the interaction matrix; user-based vs item-based; similarity measures; serendipity, sparsity, and cold-start limits), content-based filtering and cold start (recommend by item features; handles new items and niche users; the three faces of cold start and the toolkit — content features, onboarding, popular fallbacks, exploration; why hybrids win), matrix factorization and embeddings (latent factors, the dot-product model, the Netflix Prize; users and items as embeddings in a shared space — the seed of the modern field), the two-stage architecture (retrieve-then-rank: candidate generation narrows millions to hundreds via embedding ANN search, then a precise ranker orders them, then filtering/shaping — the same pattern as search and RAG), deep-learning recommenders (two-tower retrieval and rich neural ranking with cross-features, sequences, and multi-objective), evaluating recommenders (ranking metrics like NDCG/Precision@K, online A/B testing as ground truth, the offline-online gap and exposure bias, feedback loops), and production recommenders (millisecond serving, freshness, cold start and the long tail, filter bubbles and responsible recommendation, and a practical build path). Includes an interactive archify pipeline diagram. Grounded in Wikipedia, Google's ML recommendation course, and the Netflix Prize.
RegTech: Compliance as Engineering
Building regulatory compliance as software — compliance as an engineering discipline, KYC and identity verification, AML transaction monitoring, sanctions screening, immutable audit trails, data privacy, regulatory reporting, and the integrated compliance platform.
Sales & PreSales for Engineers
Sales for technical people who dislike selling — reframing sales as honestly helping customers solve problems, the sales process and pipeline, discovery and qualification, the presales/sales-engineer role, demos and proofs of concept, objections and negotiation, consultative and solution selling, and how sales connects to product and the whole business.
Self-Evolving Agents
Agents that improve themselves — memory and reflection, self-refining prompts, tool and skill acquisition, self-critique loops, population methods, and the evaluation and guardrails that keep evolution safe.
Self-Evolving Agents: The Frontier
The research frontier of agents that evolve their own design — automated design of agentic systems, evolutionary and population search, self-play and co-evolution, reflective optimizers, meta-agents and self-reference, evaluating open-ended improvement, and the real limits and risks.
smolagents, Concept by Concept
Hugging Face's minimal, code-first agent library concept by concept — what smolagents is, code agents (actions as code), why code actions win, secure sandboxed execution, tools, models, the agent loop and multi-agent systems, and when to use it.
Software Supply Chain Security
Defending the software supply chain (DevSecOps) — the new attack frontier (you ship your dependencies' code and the build that assembled it; SolarWinds/Log4Shell/registry attacks; shift from implicit trust to explicit verification), the anatomy of attacks (typosquatting, dependency confusion, compromised packages/builds, maintainer social engineering), dependency security (pinning/lockfiles, SCA scanning, update discipline, minimizing deps), SBOM (a complete inventory to answer "are we affected?" in minutes; SPDX/CycloneDX), provenance and attestation (in-toto, SLSA levels, verifiable build metadata), signing and verification (Sigstore keyless signing, transparency logs, verify-before-use), securing the build (isolation, hermetic and reproducible builds, unforgeable platform-generated provenance), and building a program (highest-leverage-first roadmap, enforce in pipeline, continuous scanning, governance). Grounded in CISA/SBOM, SLSA, Sigstore, OpenSSF.
Startup Funding & Fundraising
A practical guide to startup funding for technical founders — why and how companies raise, the funding stages (bootstrapping through Series C), equity/cap tables/dilution, valuation (pre- vs post-money), early instruments (SAFEs and convertible notes), term sheets and key terms (liquidation preferences, control), alternatives to VC (bootstrapping, revenue-based financing, venture debt, grants), and the fundraising process and investor relations.
Strands Agents, Concept by Concept
AWS's open-source, model-driven agent SDK concept by concept — the model-driven approach, the agent loop, tools and MCP, model providers, multi-agent systems, observability, and when to use it.
System Design Fundamentals
The building blocks of large-scale systems — caching, sharding, queues, consistency, and the trade-offs behind every design decision.
The AI Cost Optimization Playbook
A detailed, vendor-grounded playbook for cutting AI and cloud cost — the four governing frameworks, the ranked inference levers (caching, batching, token hygiene, model selection, effort tuning, budgets, commitments), cloud fundamentals, measurement and unit economics, and developer-tooling spend. Every figure is the vendor's own directional number — verify on your workload.
The AI Forward Deployed Engineer
The technical playbook for deploying AI/LLM systems inside a customer's environment — the AI-specific companion to the foundational Forward Deployed Engineering series. The rise of the AI FDE (the Palantir-born role exploded in the AI era because frontier models widened the demo-to-value gap; a model is a capability, not a solution; the FDE does the hard 80% — grounding, evaluation, integration, trust), scoping an AI use case (fit vs value, resisting AI theater, when AI is/isn't the right tool, augmentation over automation, picking a measurable wedge), from demo to pilot (the AI demo is a trap dressed as a triumph — cherry-picked inputs with failures edited out; use it to win belief then cross the chasm from a prompt to a system), grounding AI in the customer's data (retrieval-augmented generation reference architecture: ingest/clean/chunk/embed into a permissioned vector store, then retrieve/rerank/ground via a gateway with citations; messy+permissioned+incomplete data; bad answers are usually retrieval failures — with an interactive archify architecture diagram), evaluation and trust (you can't ship AI you can't measure; the customer's own eval set as crown jewel; offline+online; safe failure via abstention/citations/human-in-the-loop; trust is demonstrated not given), integrating AI into real workflows (value happens in the workflow not the model; UX of uncertainty; calibrated reliance; autonomy spectrum assistive→augmented→autonomous; change management), productionizing and handover (cost as a first-class constraint, latency, drift, observability, the AI gateway; making yourself unnecessary; transferring the eval discipline and runbook, not just code; permanent human-in-the-loop where stakes demand), and from bespoke AI to product (bespoke-first is right for AI; the rule of repetition; extract the recurring substrate — grounding pipeline, eval harness, gateway/observability, guardrail/UX patterns — into a platform; the flywheel and the AI FDE career arc). Grounded in Wikipedia (Palantir, RAG, human-in-the-loop, MLOps, concept drift, change management, TCO, solution architecture), the RAG paper (Lewis et al. 2005.11401), and Google's Rules of ML.
The Fintech Engineering Handbook
The engineering behind financial systems — ledgers, money movement, KYC/AML, ISO 20022, and the correctness guarantees fintech demands.
The Software Architect's Path
What it takes to grow into a software architect — quality attributes, trade-off analysis, documentation, and stakeholder-driven design.
TypeScript from the Ground Up
TypeScript for engineers who already program — why put types on JavaScript (a structural type checker that erases to plain JS at build time), the structural type system (structural vs nominal, inference, interface vs type, literal types, any/unknown/never), unions and narrowing (discriminated unions, control-flow narrowing, exhaustiveness with never, custom type guards), generics (type variables, constraints, keyof, default parameters), utility and mapped types (Partial/Pick/Omit/Record, keyof/indexed access, mapped/conditional/template-literal types — computing types from types), typing async code and the event loop (Promise<T>, async/await, Promise.all, unknown errors), modules/config/tooling (ES modules, tsconfig, strict mode, declaration files, transpile vs type-check), and idiomatic TypeScript at scale (annotate boundaries, avoid any, make impossible states impossible, migration). Completes the language-series set alongside Go, Python, and Rust.
Vector Search Internals
How approximate nearest-neighbor search actually works — the recall/latency/memory triangle, distance metrics, brute force, IVF, HNSW, vector quantization, filtering and hybrid search, and choosing and operating an index in production.
Voice and Conversational AI
Building real-time voice agents from the ground up — the anatomy of a voice agent (the cascaded pipeline: microphone → VAD → ASR → LLM → TTS → speaker, looping each turn), speech-to-text (Whisper-style ASR, streaming vs batch, endpointing), the LLM turn (time-to-first-token, speech-friendly concise output, conversation state under latency pressure), text-to-speech (streaming synthesis, text normalization, voice choice and ethics), latency (the make-or-break constraint and how streaming everything collapses additive delay), turn-taking and barge-in (endpointing, interruption, echo cancellation, cancelling in-flight work), speech-to-speech and the new realtime architectures (cascade vs end-to-end multimodal tradeoffs), and building/productionizing (telephony, robustness, holistic evaluation, deployment). Includes interactive archify pipeline and conversation-turn diagrams. Grounded in Whisper, VAD/turn-taking, and realtime-voice references.
Web Identity: OAuth, OIDC, and SAML
How web identity actually works — authentication vs authorization, OAuth 2.0 and its flows, tokens and JWTs, OpenID Connect, SAML enterprise SSO, sessions and single sign-on, and securing identity in practice.
AI Architecture Decisions
Honest decision guides for the AI architecture choices that matter — the meta-framework, agent frameworks, model platforms, RAG vs fine-tuning vs long-context, MCP vs A2A, managed vs self-hosted, and vector storage — framed by durable trade-offs, not hype.
Python Programming
An original Python-language curriculum, from fundamentals through idiomatic, production-ready Python.
The Forward Deployment Stack
A 4-part series by Pratik Dhanave on The Forward Deployment Stack.