Platform & AI Engineering

A practical release-evidence structure for deciding whether one exact AI workflow revision should ship, ship with conditions, wait, or be blocked.

Reader outcome: Reader can structure an AI workflow release decision around an exact subject, applicable evidence, known failures, accountable approval, rollback, expiration, and re-review triggers without confusing the record with certification or proof of safety.

A fixture-backed comparison that holds the BLS source, transformations, K-means settings, and acceptance criteria constant, then asks what Elixir and Python make easier to inspect and trust.

Reader outcome: Reader can design a cross-stack experiment that tests output agreement without turning a small analytical workload into a misleading language benchmark.

Two recent preprints make the practical case for quarantining, pinning, reviewing, and testing third-party agent skills before installation.

Reader outcome: Adopted a repository-pinned, line-by-line intake process for third-party agent skills without overstating early security research.

A practical set of prompts for planning, implementation, review, PR repair, Codex Goals, scheduled triage, and skill mining without turning 'keep going until green' into an unbounded agent loop.

Reader outcome: Reader can choose the right agent-loop trigger, write an auditable completion contract, separate orchestration from disposable workers, and adapt production-ready prompt variants for implementation, PR triage, and skill validation.

A public-source reference architecture showing where a private open model can reduce repeated API work without becoming the source of truth for acreage, identity, reconciliation, or submission.

Reader outcome: Mapped private models, hosted models, deterministic rules, and human authority onto an auditable acreage-reporting custody chain with promotion metrics.

A July 2026 field guide to choosing self-hosted open models by exact checkpoint, license, resident memory, usable context, workload quality, and production economics.

Reader outcome: Replaced best-model listicle logic with an auditable deployment envelope for selecting and validating small self-hosted models.

Why a $1.05 Cloud Run L4 hour can be cheaper or more expensive than hosted inference depending on utilization, throughput, fallback rate, and accepted business outcomes.

Reader outcome: Built a reproducible cost model for comparing Cloud Run GPU capacity with token-priced APIs using active hours, workload shape, fallback, and accepted-result economics.

A production-oriented Cloud Run and vLLM design that keeps GPT-OSS private, separates routing from inference, and makes model loading, readiness, concurrency, and rollback explicit.

Reader outcome: Produced a deployable service contract for private OpenAI-compatible inference with IAM authentication, pinned artifacts, measured concurrency, and a scale-to-zero operating path.

Why adding a private open model beside hosted APIs fails unless routing, fallback, evaluation, and authority are designed as one production contract.

Reader outcome: Defined a hybrid inference contract that routes bounded work to a private model while preserving hosted-model fallbacks, deterministic validation, and human review.

A practical 2026 map of AI agent frameworks by infrastructure primitive: orchestration, tools, state, multi-agent delegation, approvals, observability, evaluation, and deployment.

Reader outcome: Reframed agent-framework selection away from tier lists and toward an operating contract for which primitives the framework owns, which ones the team must own, and where bespoke orchestration is still justified.

A decision map for when Python teams should keep asyncio, use multiprocessing, try subinterpreters, or pilot free-threaded CPython without importing new race conditions.

Reader outcome: Separated Python concurrency choices by workload, state sharing, dependency readiness, and failure mode so free-threaded builds become a measured pilot instead of a default switch.

A Python architecture map for AI, data, and backend teams that need notebooks, prompts, evaluations, services, repositories, and infrastructure to stop collapsing into one folder.

Reader outcome: Defined a production Python layout for AI and data systems that separates experimentation, evaluation, domain logic, infrastructure adapters, and deployable service code.

A Python performance playbook for choosing data structures, profiling tools, vectorized libraries, JIT experiments, and concurrency changes from evidence instead of taste.

Reader outcome: Provided a performance triage workflow that asks for a measured bottleneck before changing algorithms, data structures, runtime flags, concurrency models, or native libraries.

A production Python project skeleton that prevents import confusion, dependency drift, and toolchain sprawl before the first API route or model workflow ships.

Reader outcome: Specified a repo baseline with src layout, uv locking, Ruff, typed checks, pytest, dependency groups, and CI gates so Python projects begin with executable architecture.

A practical Python 3.13+ operating standard for teams that need typed, readable, measurable systems without mistaking every new interpreter feature for a production default.

Reader outcome: Turned a pile of Python 3.13, 3.14, and 3.15-era advice into an adoption contract: stable defaults now, measured pilots for runtime changes, and automated gates before production.

How to use modern Python typing, protocols, dataclasses, and payload types to stop raw dictionaries from becoming the hidden architecture of a production system.

Reader outcome: Gave Python teams a boundary pattern for converting untrusted payloads into typed domain objects before service logic, repositories, and agent tools can depend on them.

A modern Python style guide for choosing clear comprehensions, explicit None checks, pattern matching, t-strings, and domain exceptions where they improve system behavior.

Reader outcome: Converted Pythonic style advice into boundary rules for payload dispatch, template rendering, exception design, and readable transformations in production code.

A dbt on BigQuery starter kit for the parts that usually fail after the demo: raw loads without partition filters, snapshots with weak change detection, and CI that lets expensive SQL promote.

Reader outcome: Reader can scaffold a dbt and BigQuery project with manifest-backed incremental loads, timestamp-first snapshots, partitioned models, and a dry-run bytes gate before production promotion.

Half the 2025 AI-governance recipes still in production cite documents that were rescinded, delayed, or replaced in the last twelve months. The current map: what got retired, what's still authoritative, and what an operating governance program actually has to cover in 2026.

Reader outcome: Reader can audit their AI/data governance program against the actual 2026 regulatory and standards stack, including the federal rescissions, the EU AI Act timeline shift agreed May 7, 2026, the ISO/IEC 5259 Part 5 publication, and the OWASP Agentic Top 10, and retire stale references with confidence.

Why custom LLM logging leaves you flying blind in production, and how OpenTelemetry's GenAI semantic conventions turn every model call, tool invocation, and agent step into a traceable, cost-accountable span.

Reader outcome: Reader can instrument an LLM pipeline or agent workflow with OTEL GenAI conventions, export spans and cost metrics to any compatible backend, and build alerts on real token spend and latency instead of inferring from flat logs.

Why standard code review misses capability escalation in skill manifests, and how to wire a pre-merge conftest policy gate and post-merge SLSA provenance chain that actually work — correcting three common mistakes in the recipes that circulate online.

Reader outcome: Reader can wire a working pre-merge OPA/conftest gate on skill manifests, add a correct post-merge SLSA L2 provenance workflow using the SLSA GitHub Generator reusable workflow (not the nonexistent slsa CLI), and align OTel instrumentation with the GenAI semantic conventions.

Why a two-day debug session on a one-month-old AI-generated bug is not a debugging problem but a theory-building problem you skipped, and the operating discipline that makes the missing theory recoverable.

Reader outcome: Reader has a working definition of comprehension debt distinct from technical debt, three questions to test whether a theory exists for an AI-generated component, a PR comprehension scoring rubric, and a deliberate-practice tactic set that prevents the doom loop.

When a SaaS product should graduate from a flexible Python-first backend into Go, gRPC, Cloud Run, and Google Cloud service boundaries.

Reader outcome: Mapped a Go and gRPC adoption path for SaaS teams that need stronger service contracts, concurrency, latency discipline, and Google Cloud operations without premature rewrites.

How to use BigQuery primary and foreign key constraints from dbt without confusing optimizer metadata for enforced data integrity.

Reader outcome: Defined a BigQuery and dbt constraint playbook that keeps optimizer hints, dbt contracts, data tests, compiled SQL review, and INFORMATION_SCHEMA verification in the right order.

A critical guide to README.md, AGENTS.md, CLAUDE.md, SKILL.md, .agents, and .claude patterns for teams that want coding agents to follow repo rules without stuffing every workflow into one giant prompt.

Reader outcome: Defined a repo documentation harness that separates human orientation, always-loaded agent rules, tool-specific compatibility files, on-demand skills, dynamic docs, and deterministic enforcement.

Why an ADK 2.0 ToolConfirmation flow paired with VertexAiSessionService re-presented the same approval to a reviewer on Monday morning and ran the tool twice, and what the gap tells you about how to evaluate harness primitives at different maturity levels.

Reader outcome: Reader can map ADK 2.0 primitives onto a session-service backing store and decide which combinations are production-ready, which are beta-with-known-gaps, and which require waiting.

What an oversized iOS binary, a Linux linker error, and a SQL boundary teach about embedding DuckDB as the Parquet reader for languages without a mature native library.

Reader outcome: Reader can decide when DuckDB is the right Parquet path for a Swift or Zig project, configure the SPM and build.zig integrations correctly the first time, and avoid the binary-size and linker failures that the unconfigured path produces.

How a compact Python ML cheatsheet becomes useful when synthetic demos, metrics, pipelines, and version drift are tied to the model-review decisions they can actually defend.

Reader outcome: Reader can use minimal scikit-learn examples as smoke tests for task framing, metric choice, pipeline boundaries, and environment drift instead of treating them as production recipes.

AI coding agents are turning software work into management work: engineers now have to manage intent, context, agent output, teammate coordination, stakeholder evidence, and long-term maintenance.

Reader outcome: Defined a public operating model for engineers and consultants who need to coordinate human teammates and AI agents without producing artifacts that create hidden technical debt.

Why a precompiled-NIF fall-through on a less-common Linux target adds quiet minutes to a deploy, and what the borrowed-runtime pattern actually looks like for Elixir and Mojo.

Reader outcome: Reader can ship Parquet-reading Elixir without surprise source compilation in CI, recognize where Mojo's Python interop boundary is the bottleneck rather than Mojo itself, and know which DataFrame guarantees leak at the BEAM and PyArrow boundaries.

A scikit-learn NPS ordinal classifier with SMOTE, probability calibration, utility-based thresholding, and PSI drift checks. The parts that make it useful to the retention team, not just accurate on a dashboard.

Reader outcome: Shipped a calibrated multiclass NPS model with a utility-driven operating threshold and a PSI-based drift loop, giving the retention team a per-customer detractor probability they can act on and a rule for when to retrain.

An Android-first operating pattern for using GitHub Copilot, Amazon Q Developer, Android CLI, and Android skills without letting coding assistants rewrite Gradle, manifests, architecture, and security posture by accident.

Reader outcome: Defined a repeatable assistant workflow for Android teams that combines sliced prompts, repo instructions, Android skills, screenshots, atomic commits, tests, and GHAS gates into one controlled development loop.

Why a default Go parquet.Read[T] call slurped a 1.4 GB file into 11 GB of resident memory, and the column-native Rust and Go patterns that replaced it.

Reader outcome: Reader can pick the streaming Parquet read path in Rust and Go, configure the compression-codec features explicitly, and avoid the eager-load anti-patterns that look fine in benchmarks and break in production.

A repo-ready operating contract for agent skills that prevents prompt bundles from drifting into unsigned, over-permissioned, unreviewed production dependencies.

Reader outcome: Defined a hardened-by-default skill contract covering version pins, manifest provenance, prompt review, IO tests, least-privilege tools, runtime isolation, observability, rotation, and decommissioning.

Why teams using Claude, GPT-style coding agents, Cursor, and Copilot often get unstable app work when requirements, versions, conventions, tests, and handoffs are implicit.

Reader outcome: Defined a docs-first assistant workflow that turns requirements, pinned stack choices, task slices, review loops, tests, and Git checkpoints into a repeatable way to ship with AI without surrendering architecture control.

A short, honest read on what AI researchers actually do day to day, written from outside the role by an applied engineer who reads papers when the work demands it.

Reader outcome: Reader can distinguish AI research work from applied AI engineering work, decide which research outputs change their quarter and which do not, and avoid hiring or being hired against the wrong role description.

A practical reading path through software design, architecture, system design interviews, data-intensive applications, and systems analysis for engineers who want to grow beyond implementation.

Reader outcome: Reviewed the architecture and system design books from the DEV Community list, corrected the list count, summarized each book, and arranged them into a practical learning path.

A practical MLX-first recipe for experimenting with openai/gpt-oss-20b on a 64GB Apple Silicon Mac without confusing local LoRA work for CUDA-scale training.

Reader outcome: Defined a local 64GB MacBook Pro fine-tuning path for GPT-OSS 20B that prioritizes Harmony formatting, MLX quantized LoRA, small evals, and a clear fallback to NVIDIA when scale is required.

Why Apple Silicon is useful for local LLM prototyping and LoRA experiments, but still has sharp boundaries compared with CUDA-scale NeMo or Hugging Face training.

Reader outcome: Separated Mac-local MPS and MLX fine-tuning paths from NVIDIA-only training features so local experiments can start with realistic hardware expectations.

Why Hugging Face's faster Transformers work matters beyond GPT-OSS, and how kernels, MXFP4, parallelism, KV cache, batching, and model loading change practical LLM runtime decisions.

Reader outcome: Mapped the GPT-OSS-era Transformers runtime features into concrete decisions about memory, compute, cache behavior, batching, and serving boundaries.

Why LLM fine-tuning projects fail when teams jump to NeMo or Hugging Face training commands before deciding the model, data, evaluation, serving, and governance loop.

Reader outcome: Defined a fine-tuning operating loop that connects base-model choice, data curation, PEFT, evaluation, distributed training, serving, and governance into one repeatable release path.

A grounded read of NVIDIA's NVFP4 training post and why 4-bit pretraining matters for model quality, token throughput, cost, and AI infrastructure strategy.

Reader outcome: Explained NVIDIA's NVFP4 training recipe, separated the credible technical signal from the marketing surface, and connected low-precision training to practical AI infrastructure decisions.

A practical synthesis of Drew Breunig, Simon Willison, and Anthropic on how long contexts fail, how to fix them, and why multi-agent systems need context discipline.

Reader outcome: Turned long-context failure modes into an engineering playbook for selecting, isolating, pruning, summarizing, offloading, and evaluating context in agent systems.

A practical map from algorithmic complexity to software engineering, data pipelines, machine learning systems, and modern LLM architecture decisions.

Reader outcome: Connected classical algorithm analysis to production software, ML pipelines, RAG systems, model serving, and the trade-offs behind modern AI research.

How to turn DSPy and RAG evaluation into a production release loop with golden sets, retrieval checks, generation rubrics, regression thresholds, and versioned prompt programs.

Reader outcome: Promoted the note into an essay by defining a repeatable RAG evaluation workflow that separates retrieval quality from generation quality and blocks prompt-program regressions before release.

A practical evaluation loop for multi-agent workflows that catches demo-friendly failures in task handoff, tool use, permissions, latency, and completion criteria before release.

Reader outcome: Established a repeatable evaluation workflow that gates multi-agent releases on task completion, handoff quality, tool correctness, latency, and recoverability instead of demo impressions.

A practical ML terminology guide for model reviews where feature definitions, data splits, task type, optimization behavior, overfitting risk, regularization, ensembles, and embeddings need to be discussed precisely.

Reader outcome: Gave peers a review-ready vocabulary for inspecting ML systems by connecting core terms to design choices, failure modes, and release questions.

A production-friendly pattern for pairing scikit-learn preprocessing graphs with PyTorch models so training and inference use the same feature contract.

Reader outcome: Defined an artifact contract that keeps column preprocessing, feature order, model weights, metadata, and inference behavior synchronized across batch and serving environments.

A Dataform and BigQuery case study for turning data contracts, release lanes, validation gates, rollback behavior, and cost checks into one governed promotion path.

Reader outcome: Reader can inspect a sanitized release pattern that makes schema, freshness, cost, and downstream-impact checks part of promotion rather than after-the-fact review.

A practical guide to running MCP servers locally, choosing affordable clients, and deploying private open models with Cloud Run, Ollama, and Open WebUI.

Reader outcome: Separated local agent tool access from private model serving, then defined a safer setup for MCP clients, local servers, and Cloud Run GPU sidecars.

A Confluence-ready guide for designing durable HTTP APIs and wrapping them safely as Model Context Protocol servers.

Reader outcome: Turned general API design guidance into a practical standard for HTTP APIs that back MCP servers, with current protocol corrections, checklists, and source links.

How imbalanced classifiers can keep a strong AUC while producing probabilities that break thresholds, alerts, and cost-sensitive decisions in production.

Reader outcome: Defined a production calibration gate that logs Brier score, ECE, reliability diagrams, cost-sensitive thresholds, run metadata, and promotion criteria for imbalanced classifiers.

A sanitized GCP platform case study where compliance, analytics delivery, and ML feature access had to be designed as one release path instead of three disconnected workstreams.

Reader outcome: Reader can inspect a sanitized GCP pattern for governed dataset onboarding, auditability, cost visibility, and promotion rules across analytics and ML use cases.

Why tabular models drift between notebooks and production when preprocessing, sample metadata, hyperparameter search, and persistence are not treated as one scikit-learn pipeline contract.

Reader outcome: Defined a scikit-learn pipeline contract that keeps column preprocessing, metadata routing, hyperparameter search, evaluation, and deployment artifacts reproducible across dev, stage, and production.

A software-developer guide to the statistics that actually change data-science decisions: samples, estimates, uncertainty, effect size, bias, probability, distributions, and model metrics.

Reader outcome: Defined a practical estimate-review workflow that helps software developers report effect size, confidence intervals, p-values, sampling bias, and classification metrics without treating statistics as glossary trivia.

A production-focused Vertex AI post on turning raw data, BigQuery features, online feature serving, model endpoints, monitoring, and retraining into one governed ML loop instead of another platform checklist.

Reader outcome: Defined a concrete Vertex AI feature-serving loop with source contracts, BigQuery feature views, point-in-time training exports, endpoint serving rules, monitoring thresholds, and retraining triggers.

A Vertex AI architecture map for teams that need to decide which Google Cloud AI services belong in the ML lifecycle, where ownership changes hands, and which older assumptions are now unsafe.

Reader outcome: Gave teams an operating contract for using Vertex AI across data, features, training, deployment, monitoring, and generative AI without confusing a product menu for a production ML system.

A long-form feature-screening workflow that uses correlation for quick linear checks, then adds redundancy clustering, mutual information, chi-squared tests, L1 models, tree importances, permutation importance, and domain review.

Reader outcome: Defined a practical feature review loop that prevents teams from dropping useful nonlinear signals or keeping redundant features just because a correlation heatmap looked convincing.

A practical look at Google ADK memory, Vertex AI Memory Bank, session state, retrieval, retention, access control, and why durable agent memory needs production discipline.

Reader outcome: Clarified the difference between short-term session state and durable agent memory, then mapped the operational risks around retrieval, security, retention, cost, and memory poisoning.

Capability is no longer the hard question about AI agents. What the agent is permitted to do, and whether it will do it successfully, are. Here is why that distinction matters architecturally.

Reader outcome: Reframed agent deployment decisions around permission scope and blast radius rather than capability, reducing the risk of production failures from over-permissioned agentic systems.

Why Codex plugins point toward a different software design mindset: fewer UI extensions, more safe agent capabilities, system access points, and operational boundaries.

Reader outcome: Framed plugins as reusable agent capability bundles that require structured systems, permissions, predictable workflows, and safer operational surfaces.

OpenAI's April 2026 Agents SDK update matters because sandboxed execution, manifests, resumable state, and memory move agents closer to real production automation.

Reader outcome: Framed sandboxed agent execution as an architecture boundary for safer, stateful, long-running automation instead of another demo-layer SDK feature.

A practical AI strategy framework with a worked example that connects business levers, data readiness, pilots, evaluation, governance, deployment, and operating metrics.

Reader outcome: Defined an end-to-end AI strategy playbook and worked example that ties data readiness, use-case selection, model development, governance, deployment, and operating ownership to measurable business outcomes.

A practical deployment guide for running Ollama behind Open WebUI on Cloud Run GPUs without mixing service specs, model storage modes, sidecar startup order, or auth assumptions.

Reader outcome: Clarified Cloud Run GPU sidecar deployment choices so model storage, service YAML, startup ordering, authentication, and billing constraints are explicit before launch.

A practical runbook for scoring changed rows close to the data using Snowflake Streams and Tasks or BigQuery scheduled queries and remote models.

Reader outcome: Compared Snowflake and BigQuery patterns for scheduled in-warehouse inference, corrected CDC assumptions, and defined monitoring, grants, and deployment checks.

A practical view of data strategy as the operating discipline that connects business goals, governance, KPIs, platforms, analytics, ML, and AI delivery.

Reader outcome: Connected data roadmaps, governance, KPI design, platform delivery, and stakeholder alignment so analytics and AI initiatives produced measurable business decisions.

How to add coverage-guaranteed prediction sets, temperature scaling calibration, and risk-coverage curves to a classifier using MAPIE — the pieces that make uncertainty quantification operationally useful rather than decorative.

Reader outcome: Added coverage-guaranteed prediction sets and operational abstention gates to a classification pipeline, cutting acted-upon error rate without retraining the model.

A practical map of NVIDIA NeMo for teams that want to curate data, fine-tune open-source LLMs, evaluate them, and move from research checkpoints to production inference.

Reader outcome: Separated data curation, fine-tuning, alignment, evaluation, export, and serving concerns so open-source LLM customization could move from experiments to governed production workflows.

A practical explanation of ML metrics with decision tables for regression tolerance, rare-event classification, threshold tradeoffs, and the failure case where accuracy looked good but the decision failed.

Reader outcome: Clarified how metric choice, threshold design, tree-based pattern discovery, and logit interpretation affect whether ML outputs are useful for action.

A practical playbook for turning classifier scores into reliable probabilities that can support ranking, thresholds, SLAs, and cost-sensitive decisions.

Reader outcome: Defined a calibration workflow that separates ranking from probability quality, uses scikit-learn calibration correctly, and carries thresholds and monitoring into production.

A repeatable triage routine — the three-run baseline, DataLoader diagnosis, five profiler signatures, and a copy-paste scaffold — for finding where training time actually goes before touching the model.

Reader outcome: Identified and resolved training bottlenecks in under an hour by running the three-run baseline and reading profiler signatures before changing any model code.

torch.compile, mixed precision, gradient accumulation, DDP vs FSDP, and the profiler — the five levers I reach for before rethinking the model architecture.

Reader outcome: Cut training wall-clock time and GPU memory pressure by applying compile, AMP, and accumulation patterns in sequence before ever touching model architecture.

A production-friendly scikit-learn pattern for mixed tabular data, class imbalance, calibrated probabilities, threshold selection, and model persistence.

Reader outcome: Defined an end-to-end scikit-learn classification pipeline that keeps preprocessing, imbalance handling, probability calibration, evaluation, thresholding, and production artifacts aligned.

A practical way to use algorithm complexity in product engineering, from choosing data structures to designing recommendation features that do not collapse as data grows.

Reader outcome: Explained how algorithm complexity shows up in everyday product work, then walked through an e-commerce recommendation feature from naive loops to indexed lookup.