Platform & AI Engineering

Choose one workflow, try it on a real task, and check what your assistant actually used.

How I revised agent workflows to preserve decisions, failed checks, and unfinished work—and what limited checks across Codex, Claude, and Antigravity actually showed.

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

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.

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

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.

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.

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

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.

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.

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

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

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

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.

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

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

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.

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

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

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.

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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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

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

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

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

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

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.

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.

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

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.

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.

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.

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.

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.

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

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

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

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.

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

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

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.

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.

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.

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

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.

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

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

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.