sanjeevrg89
- 59 skills
- 0 followers
- 13 hours ago last updated
- ▌ Gke Master · sanjeevrg89 bundleGoogle Kubernetes Engine (GKE) specialist knowledge for designing and operating large ML/platform clusters on Google Cloud. Use whenever the work is GKE-specific — Standard vs Autopilot, node pools & machine families, Node Auto-Provisioning, GPU node pools (A3/A3-Mega/A3-Ultra/A4 with H100/H200/B200/GB200; time-sharing/MPS/MIG/DRA), TPU node pools (v5e/v5p/v6e Trillium, single/multi-host slices), Dataplane V2, VPC-native/NEGs/Gateway API, multi-networking & GPUDirect-TCPX/TCPXO/RDMA, Hyperdisk ML/Filestore/GCS FUSE CSI/Parallelstore, fast model loading & model streaming (run:ai Model Streamer-style streaming, FUSE caching, image streaming), Multi-Tier Checkpointing (MTC) for fast training restart, GKE Sandbox/gVisor (Agent Sandbox) for untrusted code & AI-agent tool execution, Workload Identity Federation, release channels & upgrades, Fleets/Config Sync, Backup for GKE, Managed Service for Prometheus, and GPU/TPU accelerator metrics. For generic Kubernetes use `[[kubernetes-expert]]`; this skill is the GKE la
- ▌ Graph Ml Gnns · sanjeevrg89 bundleWorld-class graph machine learning and Graph Neural Network (GNN) judgment for production — node classification, link prediction, graph classification/regression, community detection, and heterogeneous/knowledge-graph learning. Use when working with graph-structured data, relational data modeled as nodes/edges, or any GNN task; when choosing or implementing GCN, GraphSAGE, GAT, GIN, R-GCN, or graph transformers; when scaling GNNs (neighbor sampling, Cluster-GCN, GraphSAINT, distributed/ partitioned training, serving); when using PyTorch Geometric (PyG) or DGL; or for graph-based recommendation, fraud/anomaly detection on transaction graphs, molecular property prediction/drug discovery, knowledge-graph completion, and GNNs for time series (GNN4TS). Covers message passing, over-smoothing/over-squashing, expressivity (1-WL), transductive vs inductive splits, edge leakage, and OGB benchmarks.
- ▌ Ml Frameworks · sanjeevrg89 bundleDeep expertise in the core ML compute frameworks and the accelerator stack beneath them — PyTorch (eager/graph, autograd, torch.compile/Dynamo/Inductor, CUDA caching allocator & memory, AMP/bf16/fp8, torch.distributed/NCCL, DDP vs FSDP/FSDP2, profiling), JAX (jit/grad/vmap, tracing, jax.sharding/Mesh/NamedSharding/shard_map, SPMD/GSPMD, donation, compilation cache), XLA/OpenXLA (HLO/StableHLO, fusion, layout, PJRT, xla_flags, PyTorch/XLA), CUDA GPU substrate (warps/SMs, memory hierarchy, tensor cores, Triton, cuBLAS/cuDNN/CUTLASS, FlashAttention, NCCL/NVLink), and TPU substrate (MXU systolic array, VPU, ICI, pods, Pallas, megacore). Use when writing/optimizing/debugging PyTorch or JAX, tuning torch.compile or XLA, chasing CUDA/TPU OOM, recompilation, MFU/roofline, precision (tf32/bf16/fp16/fp8), or kernel-level performance. Sibling skills own distributed-training orchestration and serving.
- ▌ Multimodal Ml · sanjeevrg89 bundleWorld-class guidance for building production multimodal AI systems spanning vision, language, audio/speech, and video. Use when training or serving models that combine modalities — contrastive vision-language (CLIP/SigLIP), Vision-Language Models / multimodal LLMs (ViT encoder + projector/connector + LLM, à la LLaVA/Flamingo), ASR/TTS (Whisper), audio encoders, video temporal modeling/frame sampling, image/video generation (latent diffusion, DiT, flow matching), cross-modal embeddings and multimodal RAG. Covers the shared-representation mental model, early/late fusion, native-multimodal vs bolt-on, staged training (pretrain → align → instruction-tune), the serving cost of variable-length visual tokens on context/KV-cache, multimodal evaluation/hallucination/grounding, and the multimodal anti-patterns. Reach for it whenever a model takes images, audio, or video as input or output — not pure-text LLMs.
- ▌ Kueue Advanced · sanjeevrg89 bundleAdvanced mastery of Kueue (sigs.k8s.io/kueue), the Kubernetes-native job queueing and quota manager for batch/ML fleets. Use when working with Kueue objects — Workload, ResourceFlavor, ClusterQueue, LocalQueue, Cohort, AdmissionCheck — or when jobs are stuck Suspended/Pending/Inadmissible, when designing quota/borrowing/lending and cohorts, fair sharing, preemption, gang/all-or-nothing admission, waitForPodsReady, workload priority classes, Topology-Aware Scheduling (TAS), ProvisioningRequest, MultiKueue multi-cluster dispatch, or wiring Kueue to batch/Job, JobSet, RayJob, MPIJob, PyTorchJob/Kubeflow Trainer, LeaderWorkerSet, plain Pods, or AppWrapper. Covers the suspend/resume admission mechanism, kueue.x-k8s.io labels/finalizers, the Configuration API, troubleshooting, and sizing. Mentions feature maturity; verify current API against kueue.sigs.k8s.io.
- ▌
- ▌ Maxtext Jax LLM · sanjeevrg89 bundleExpert guidance for MaxText and the JAX LLM stack — training and serving frontier-scale LLMs (Llama, Gemma, Mistral, DeepSeek, Qwen, Mixtral/MoE) on TPU pods and GPU. Use when working with MaxText configs (base.yml/model YAML, ici_*_parallelism / dcn_*_parallelism, per_device_batch_size, remat_policy, attention=flash, weight_dtype/quantization=int8), JAX sharding (Mesh, PartitionSpec, NamedSharding, logical_axis_rules, GSPMD), Flax (linen/NNX), Optax, Grain, Orbax, Pathways, or JetStream inference; scaling to multi-host / multislice TPU (ICI vs DCN); chasing MFU, OOM, or recompilation; or launching on GKE with XPK/JobSet. Covers the FSDP/TP/sequence/expert sharding mental model and the TPU-JAX-vs-GPU-PyTorch decision.
- ▌
- ▌ Fine Tuning Peft · sanjeevrg89 bundleAdapting pretrained LLMs to tasks/domains cost-effectively via supervised fine-tuning (SFT) and parameter-efficient fine-tuning (PEFT). Use when deciding fine-tune vs prompt/RAG, or when running LoRA, QLoRA, DoRA, (IA)³, prefix/prompt/P-tuning; building SFT/instruction-tuning data; setting rank/alpha/target modules; doing 4-bit NF4 + paged-optimizer training; chat templates, packing, completion-only loss masking; merging adapters and multi-LoRA serving; and the memory math for what fits on one GPU. Covers the HF PEFT + Transformers/TRL stack, Axolotl, Unsloth, Llama-Factory, torchtune, NeMo, and bitsandbytes. For distributed/full pretraining see [[training-frameworks]]; for preference/RL post-training (DPO/PPO/GRPO) see [[rl-rlhf-frameworks]]; for serving adapters see [[serving-frameworks]]/[[gke-inference-gateway]].
- ▌ Ml System Design · sanjeevrg89 bundleWorld-class playbook for designing end-to-end ML systems — the "tie it all together" architect skill, covering both real-world production architecture and the ML-system-design interview. Use when asked to design an ML/AI system, scope an ML feature, do an ML system design interview, or reason about a recommendation/ranking, search/retrieval, feed, ads/CTR, classification, fraud/anomaly, or LLM/RAG/agent system end to end. Provides a repeatable framework (clarify problem & business metric → ML objective → data/labels & the third pipeline → features → model → training pipeline → offline+online evaluation → serving (online/batch/streaming, latency budget) → monitoring & iteration), the canonical problem archetypes, the key design axes/tradeoffs (online vs batch, latency vs throughput vs cost, candidate generation→ranking→re-ranking funnels, freshness, training-serving skew, cold start, feedback loops, scale & failure modes), how to choose and defend business/ML/guardrail metrics, and the anti-patterns.
- ▌
- ▌ Edge On Device Ml · sanjeevrg89 bundleDeploying ML models on edge / mobile / embedded devices — the runtimes, hardware, and conversion craft for running models off the datacenter. Use when targeting phones, laptops, wearables, cameras, vehicles, or microcontrollers; when you see ExecuTorch, TensorFlow Lite / LiteRT, ONNX Runtime Mobile/Web, Core ML / coremltools, MediaPipe, llama.cpp / ggml / GGUF, MLC-LLM, MNN, NCNN, TFLite Micro; when targeting Apple Neural Engine, Qualcomm Hexagon, Google Tensor, Edge TPU / Coral, or GPU/NPU delegates; or when the task is exporting/converting a model (torch.export, .pte, .tflite, .mlpackage, .onnx), picking and tuning a delegate, debugging unsupported ops or numerical parity vs the source model, INT8/INT4 on-device quantization and the quality cliff, on-device LLM KV-cache/memory budgeting, OTA model updates and rollback, or on-device profiling. The general compression theory lives in `[[inference-optimization]]`; THIS skill is the edge *deployment target* — runtimes, hardware, conversion pipeline, and on-devi
- ▌ Go Best Practices · sanjeevrg89 bundleWorld-class Go guidelines aligned to the Google Go Style Guide (Style Guide, Style Decisions, Best Practices) plus community consensus, for writing, reviewing, and refactoring Go. Use whenever working in a Go codebase (.go files, go.mod) — authoring packages/APIs, handling errors, concurrency/goroutines/context, interfaces, testing, performance, or reviewing a Go diff/PR. Covers Google's clarity>simplicity>concision>maintainability>consistency hierarchy, naming/receiver/error decisions, %w wrapping, goroutine lifecycle, table-driven tests with go-cmp, and a review checklist.
- ▌ Kubernetes Expert · sanjeevrg89 bundleEnd-to-end Kubernetes practitioner mastery for using K8s well in production — authoring, reviewing, debugging, and operating workloads on real clusters. Use when working with Pods, Deployments, StatefulSets, DaemonSets, Jobs/CronJobs, Services, Ingress/Gateway API, NetworkPolicy, PV/PVC/StorageClass/CSI, ConfigMaps/Secrets, RBAC/ServiceAccounts, Pod Security Admission, securityContext, ResourceQuota/LimitRange, HPA targets, probes, PodDisruptionBudgets, taints/ tolerations, affinity, topology spread; writing or reviewing K8s manifests/Helm/Kustomize; or debugging CrashLoopBackOff, ImagePullBackOff, Pending, OOMKilled, evictions, and rollout failures with kubectl. Covers requests/limits, QoS, scheduling, zero-downtime rollouts, graceful termination, multi-tenancy, and a production-readiness checklist. NOT for control-plane source internals or writing controllers/operators (see related skills).
- ▌ Ray On Kubernetes · sanjeevrg89 bundleExpert guidance for running Ray on Kubernetes via the KubeRay operator — RayCluster, RayJob, and RayService CRDs for distributed training (Ray Train), HPO (Ray Tune), model serving (Ray Serve), streaming batch inference and data (Ray Data), and RL/RLHF (RLlib). Use when authoring or debugging KubeRay manifests, sizing head nodes, configuring the Ray autoscaler, placement groups for gang scheduling, GCS fault tolerance with external Redis, object-store/plasma spilling, GPU/TPU pools on GKE, or queueing RayJobs with Kueue. Covers the Ray core mental model (tasks, actors, object store, GCS, raylets, ownership), zero-downtime RayService upgrades, and KubeRay troubleshooting (pending actors/tasks, autoscaler not scaling, GCS restart, OOM).
- ▌ AI Security On Gke · sanjeevrg89 bundleDefensive, defense-in-depth security for AI/LLM workloads on Kubernetes and GKE — at the bar of a security engineer for an AI platform. Use when threat-modeling or hardening LLM inference, RAG, or agentic apps; designing prompt-injection / jailbreak / PII / toxicity filtering (Model Armor, Llama Guard, NeMo Guardrails, Guardrails-AI); sandboxing untrusted tool/code execution (gVisor/GKE Sandbox, Kata/microVMs, seccomp, AppArmor); runtime threat detection (GKE Security Posture, Container Threat Detection, Falco); admission control & policy (Pod Security Admission, Gatekeeper, Kyverno); image & model supply-chain (Binary Authorization, Sigstore/SLSA, safetensors vs pickle, dataset integrity); identity, secrets, and egress control (Workload Identity Federation, Secret Manager, NetworkPolicy, private clusters, Confidential GKE). Maps the OWASP LLM Top 10 to concrete controls.
- ▌
- ▌ Rl Rlhf Frameworks · sanjeevrg89 bundleExpert RL / RLHF / RLAIF post-training for LLMs at production scale — reward modeling, PPO, DPO, GRPO, RLOO, KTO, ORPO, RLAIF/Constitutional AI, rejection sampling / best-of-n, on- vs off-policy, KL control and the reference model. Use when building or debugging an RLHF/RLAIF pipeline, choosing between PPO/DPO/GRPO, picking a framework (TRL, veRL/HybridFlow, OpenRLHF, NeMo-Aligner/NeMo-RL, RLlib, TRLX, MaxText-RL), wiring the generate→score→update loop, budgeting memory across policy/reference/ reward/critic copies, splitting rollout (vLLM/SGLang) from learner (FSDP/Megatron), doing weight resharding, placing actors/learners colocated vs disaggregated on Ray/Kubernetes, or fighting reward hacking, training instability, and the generation-throughput bottleneck. Covers preference-data handling, eval, and a PPO-vs-DPO-vs-GRPO and framework decision guide.
- ▌ Serving Frameworks · sanjeevrg89 bundleExpert knowledge of modern LLM/ML inference serving — vLLM (PagedAttention, continuous batching), SGLang (RadixAttention), NVIDIA Dynamo (disaggregated prefill/decode, KV-aware routing), Triton Inference Server, TensorRT-LLM, Ray Serve, KServe, JetStream (JAX/XLA on TPU), NVIDIA NIM (prepackaged inference microservices), and TGI. Use when deploying, tuning, or choosing an inference engine; reasoning about prefill vs decode, KV cache / PagedAttention / prefix caching, continuous/in-flight batching, TTFT/ITL/TPOT/goodput, tensor/pipeline/expert parallelism, multi-host serving, disaggregated serving, speculative/chunked-prefill decoding, fp8/AWQ/GPTQ quantization, structured/guided output, or serving autoscaling and KV-cache-aware routing on Kubernetes/GKE. Covers engine differentiators, a decision matrix, and K8s deployment shapes.
- ▌
- ▌
- ▌
- ▌ Ml Compilers Codegen · sanjeevrg89 bundleDeep expertise in ML compilers and code generation — how models are lowered to fast hardware kernels. Covers the compilation stack (graph capture → high-level IR → optimization passes → lowering → target codegen → runtime), MLIR (dialects, progressive lowering, reusable infrastructure) and StableHLO/HLO as the portable ML IR, XLA/OpenXLA (HLO pipeline, algebraic simplification, layout assignment, operator fusion, buffer assignment, XLA:GPU native-PTX-via-LLVM and Triton emitters, PJRT, AOT vs JIT, shape specialization/recompilation), Triton (tile model, TTIR→TTGIR→LLVM/PTX dialects), fusion in depth (vertical/horizontal/epilogue, FlashAttention, the memory wall), and torch.compile (Dynamo→AOTAutograd→Inductor→Triton), TensorRT, ONNX Runtime, IREE, TVM. Use when reading/debugging IR dumps (HLO, TTIR/TTGIR, FX/Inductor output), chasing recompilation or fusion failures, autotuning, writing a custom kernel/pass, or deciding when the compiler helps vs hurts. This is the compiler/IR/ codegen deep dive beneath ml-fr
- ▌ RAG Vector Databases · sanjeevrg89 bundleExpert Retrieval-Augmented Generation (RAG) and vector-database engineering for production systems over large corpora. Use when building or debugging a RAG pipeline (ingestion, chunking, embeddings, indexing, retrieval, reranking, context assembly, generation), choosing or tuning a vector DB (Milvus, Qdrant, Weaviate, pgvector/AlloyDB AI, Pinecone, Vespa, Elasticsearch/OpenSearch), picking ANN indexes (HNSW, IVF, IVF-PQ/OPQ, ScaNN, DiskANN) and quantization (PQ/SQ/binary), implementing hybrid search (BM25/SPLADE + dense, RRF fusion), cross-encoder reranking, query rewriting/HyDE/multi-query/ multi-hop/GraphRAG/contextual retrieval, metadata filtering, evaluation (recall@k, MRR, nDCG, RAGAS, faithfulness), or deploying a vector DB on Kubernetes/GKE (StatefulSet, sharding, replication, sizing, backups). Triggers on symptoms like poor recall, irrelevant chunks, hallucinated answers, slow ANN queries, OOM on in-memory indexes, or "cosine vs dot vs L2" distance-metric mismatch.
- ▌
- ▌
- ▌
- ▌ Privacy Preserving Ml · sanjeevrg89 bundlePrivacy-enhancing technologies (PETs) for machine learning — the engineering techniques to train and serve models without leaking private training data. Use when you must train/fine-tune/serve on sensitive data (PII, PHI, financial, on-device), when facing membership-inference / model-inversion / training-data-extraction (memorization) attacks, or when a requirement says "private", "anonymized", "GDPR/CCPA", "right-to-be-forgotten", "data can't leave the device/silo", or "no raw data sharing". Covers differential privacy (the (ε,δ) definition, DP-SGD gradient clipping + noise, privacy accounting via RDP/moments accountant/PRV, DP-FTRL, DP fine-tuning & synthetic data), federated learning (FedAvg, cross-device vs cross-silo, non-IID, secure aggregation, FL+DP composition, TFF/Flower/FedML/PySyft), cryptographic PETs (homomorphic encryption, secure multiparty computation, private set intersection, trusted execution environments / confidential computing), and machine unlearning (SISA, exact vs approximate, verif
- ▌ Staff Operating Modes · sanjeevrg89 bundleStaff Operating Modes (drive the agent at a distinguished bar)
- ▌ Autoscaling Kubernetes · sanjeevrg89 bundleExpert mastery of autoscaling on Kubernetes across all layers — pod-horizontal (HPA), pod-vertical (VPA, in-place resize), node (Cluster Autoscaler, Karpenter, GKE Node Auto-Provisioning), and event-driven (KEDA). Use when designing or debugging HPA control loops (desiredReplicas, behavior, stabilization windows), custom/external metrics (custom.metrics.k8s.io, external.metrics.k8s.io, Prometheus Adapter), VPA modes and HPA-vs-VPA conflicts, Cluster Autoscaler vs Karpenter (NodePools, consolidation, disruption), KEDA ScaledObjects/ScaledJobs and scale-to-zero, Kueue ProvisioningRequest, or ML/GPU/LLM-inference autoscaling (GPU utilization, queue depth, TTFT/concurrency, scale-to-zero for accelerators, multi-host LWS). Covers tuning, metric-pipeline reliability, and autoscaler fights.
- ▌
- ▌ Inference Optimization · sanjeevrg89 bundleModel-level LLM inference optimization and efficiency — making models smaller, faster, and cheaper to serve at the level of an engineer who squeezes frontier models onto fewer accelerators. Use when quantizing (PTQ vs QAT, INT8/INT4, FP8, GPTQ, AWQ, SmoothQuant, GGUF, NF4, KV-cache quant), pruning/sparsifying (structured, 2:4 semi-structured, layer/width pruning), distilling (teacher→student, sequence-level/on-policy), or speeding up decode with speculative decoding (draft models, Medusa, EAGLE, lookahead, n-gram, self-speculative). Also covers low-rank/structural efficiency (LoRA, MoE, GQA/MQA/MLA, FlashAttention) and compilation/kernels (torch.compile/Inductor, TensorRT-LLM engine build, ONNX Runtime, XLA, Triton/CUTLASS, CUDA graphs). Reach for it to reason about the memory-bandwidth vs compute bound, arithmetic intensity, accuracy recovery, acceptance-rate economics, and which technique buys latency vs throughput vs memory vs $/token vs quality. The serving *engine* that runs the result is `[[serving-fram
- ▌
- ▌ Ml Checkpointing Orbax · sanjeevrg89 bundleExpert ML checkpointing at scale for resilient large-model training, centered on Orbax (the JAX checkpointing library) with the full landscape. Use when saving/restoring model state in JAX/Flax or PyTorch training, when training stalls or wastes work on failures, or when designing checkpoint resilience for thousand-accelerator jobs. Covers Orbax CheckpointManager (async, sharded jax.Array, composite/PyTree, retention policies, transformations on restore, emergency/in-memory peer-replica checkpointing), PyTorch torch.distributed.checkpoint (DCP) with FSDP full/sharded state dicts and async staging, Multi-Tier Checkpointing (MTC) to node-local SSD + Cloud Storage on GKE, the GCS/Hyperdisk ML/Parallelstore IO story, goodput/MFU and save-stall math, deterministic data-iterator resume, resharding on a different topology at restore, and elastic/restartable training. Triggers on orbax, CheckpointManager, AsyncCheckpointer, DCP, FSDP state_dict, MTC, checkpoint frequency, save stall, resharding, goodput.
- ▌
- ▌ Staff Plus Engineering · sanjeevrg89 bundleThe non-technical and technical-leadership competencies that distinguish Staff, Senior Staff, Principal, and Distinguished engineers from Senior — the things that actually earn promotion past the senior "terminal" level. Use when working on technical leadership, technical strategy/vision, architecture direction, a design doc / RFC / one-pager / Amazon-style narrative, influence without authority, alignment/sponsorship/consensus, leading large ambiguous multi-team efforts, mentorship & sponsorship, the Staff archetypes (Tech Lead, Architect, Solver, Right Hand), glue work, a "staff project" or promotion case, make-vs-buy and tech-debt-as-portfolio, or org-level AI-platform strategy across training/serving/data/infra/cost/safety. Grounded in StaffEng archetypes, Will Larson's "Staff Engineer", and Tanya Reilly's "The Staff Engineer's Path". Ladders/titles vary by company.
- ▌
- ▌
- ▌
- ▌ Test Driven Development · sanjeevrg89 bundleThe Build stage of the engineering lifecycle done right — implement features and fixes test-first using red → green → refactor, keeping the build green with small commits. Use whenever you are about to write or change behavior: a new function, a bug fix, a controller/reconciler, a data transform, a training/serving config, or an ML behavior change. Tailored to AI infra / ML where people claim "you can't TDD this": shows what testing actually looks like — table-driven unit tests, controller tests with envtest, pipeline/integration tests, eval-as-test for stochastic ML behavior (invariants, contracts, properties, metric thresholds — not exact tokens), golden/snapshot tests, the race detector, determinism via injected seeds/clocks/fakes, and smoke tests for manifests/IaC. Covers the test pyramid, fakes-over-mocks, CI gates, and the checkpoint (tests written, passing, race-clean) before Verify/Review. Scope: AI-infra/ML work — for general application-level TDD loops prefer a generic TDD skill (e.g. the vendored m
- ▌
- ▌
- ▌ Embedding Model Training · sanjeevrg89 bundleWorld-class guidance for TRAINING text/retrieval embedding and reranker models — bi-encoders (dual-encoders), cross-encoder rerankers, and the retrieve-then-rerank pattern. Use when training, fine-tuning, distilling, or evaluating an embedding/retriever/reranker (contrastive/InfoNCE loss, in-batch negatives, hard-negative mining, false-negative removal, cross-encoder distillation, Matryoshka/MRL nested dims, ColBERT multi-vector, instruction-tuned embeddings, multilingual/ multimodal), or when picking embedding dimension/pooling/normalization and evaluating on MTEB/BEIR (nDCG@10, recall). This is how the MODELS are built; for serving embeddings, ANN indexes, and RAG retrieval infra see [[rag-vector-databases]].
- ▌
- ▌ Adversarial Ml Robustness · sanjeevrg89 bundleModel-level adversarial machine learning and robustness — at the bar of a researcher who breaks and defends models for a living. Use when threat-modeling an ML/LLM model, evaluating or claiming robustness, or defending against evasion / adversarial examples (FGSM, PGD, C&W, transferable & patch/ physical attacks), data poisoning, backdoors/trojans (clean-label, trigger-based), model extraction/ stealing, model inversion, membership inference, or LLM jailbreaks / training-data extraction. Covers the NIST Adversarial ML taxonomy (AI 100-2e2025) and MITRE ATLAS; threat models (white/black/gray-box, Lp budgets); defenses and their limits (adversarial training, certified/randomized smoothing, why defensive distillation & gradient masking are false security); and the core skill — honest robustness evaluation with adaptive attacks, AutoAttack, and RobustBench. Defensive, not an attack playbook.
- ▌
- ▌ Responsible AI Governance · sanjeevrg89 bundleResponsible AI governance, safety, fairness, and compliance — the discipline of building AI that is fair, safe, accountable, transparent, and auditable. Use when setting up AI governance (NIST AI RMF Govern/Map/Measure/Manage, EU AI Act risk tiers, ISO/IEC 42001, AI inventory, risk register, review board); writing transparency artifacts (model cards, datasheets for datasets, system cards, data statements, lineage); doing fairness/bias work (data/label/feedback bias, demographic parity vs equalized odds vs calibration and their impossibility, slice-based eval, pre/in/post-processing mitigation); LLM safety (harms taxonomy, red-teaming, jailbreak/misuse resistance, guardrails, hallucination/groundedness, safety evals, refusal/over-refusal, RLHF/Constitutional AI); privacy & data governance (PII, consent, data minimization, differential privacy, federated learning, machine unlearning / right-to-be-forgotten, training-data provenance & copyright); or accountability/ops (human oversight, AI incident response, audi
- ▌ Kubernetes Operator Expert · sanjeevrg89 bundleDesigning, building, and shipping production Kubernetes Operators — the API/packaging/lifecycle dimension. Use when defining CustomResourceDefinitions (CRDs), designing api groups/versions/kinds and the spec/status split, writing OpenAPI v3 / structural schemas with CEL validation rules, adding /status or /scale subresources, printer columns, defaulting, and immutability; versioning APIs (alpha/beta/GA, served vs stored versions, conversion webhooks); writing validating/mutating/defaulting admission webhooks or CEL ValidatingAdmissionPolicy; scaffolding with kubebuilder or Operator SDK (controller-gen markers that generate CRDs/RBAC/webhooks); packaging with OLM (ClusterServiceVersion, bundles, catalogs, OperatorHub) or kustomize/Helm; status conditions, events, metrics, leader election, RBAC, and capability levels. For reconcile-loop mechanics (controller-runtime, client-go, watches, workqueues) see kubernetes-controller-expert.
- ▌
- ▌ Gpu Performance Engineering · sanjeevrg89 bundleGPU kernel performance engineering and cross-layer systems profiling — the discipline of actually finding and fixing where the FLOPs and bandwidth go, at frontier scale (distinct from framework-level "make torch.compile faster"). Use when profiling or optimizing GPU kernels, reading a roofline (arithmetic intensity, compute-bound vs memory-bound, ridge point), using NVIDIA Nsight Compute (ncu — Speed-of-Light/SOL, memory & compute workload analysis, occupancy, warp-stall reasons, tensor/MMA pipe utilization, coalescing, bank conflicts) or Nsight Systems (nsys timeline/overlap, NVTX, CUPTI), diagnosing host-bound vs kernel-bound vs memory-bound vs comms-bound vs straggler problems, hunting stragglers across ranks (the "nvidia-smi 100% but a GPU thermal-throttled" pattern), doing cross-layer continuous profiling (perf/eBPF + GPU kernel tracing + NCCL/collective instrumentation), IR-embedded profiling (KPerfIR/Proton MLIR/LLVM dialects in Triton), or rigorous benchmarking with MLPerf (LoadGen, reproducibility/so
- ▌ Kubernetes Internals Expert · sanjeevrg89 bundleSource-level Kubernetes internals for debugging control-plane and node problems others can't. Use when investigating WHY the cluster behaves as it does, not just how to use it — apiserver request lifecycle (auth/authz/admission/CEL/etcd), API machinery (scheme, GVK/GVR, codecs, conversion, defaulting), the watch cache, resourceVersion/watch/bookmarks/pagination, APF/FlowSchema priority & fairness, the aggregation layer/APIServices, admission webhook plumbing; etcd (Raft, MVCC/revisions, keyspace, compaction/defrag, quota/NOSPACE, quorum); the scheduler framework (PreFilter→Bind, preemption, nominatedNodeName, scheduling queues); controller-manager (shared informers, garbage collector + owner refs/finalizers, node lifecycle/Leases, lease-based leader election); kubelet (syncLoop, PLEG, CRI/containerd/CRI-O, cgroups v2, QoS & eviction manager, device plugins, DRA, CSI, static pods); networking dataplane (kube-proxy iptables/IPVS/nftables, Service VIPs, EndpointSlices, CNI, conntrack); and cross-cutting mechanic
- ▌
- ▌ Pretraining Data Tokenizers · sanjeevrg89 bundleWorld-class guidance for building petabyte-scale LLM pretraining-data pipelines and the tokenizers that sit in front of them — the curation and vocabulary decisions that quietly set model quality and serving cost. Use when curating web-scale corpora (Common Crawl / WARC extraction, language ID, quality filtering, dedup, decontamination), deciding data mixtures/curricula/repetition, or designing/evaluating a tokenizer (BPE/Unigram/WordPiece, byte-level BPE, SentencePiece/tiktoken/HF tokenizers, vocab size, fertility/tokens-per-word, multilingual & code). Covers FineWeb/FineWeb-Edu, RefinedWeb, CCNet, DataComp-LM, Dolma, The Pile, MinHash-LSH dedup, datatrove/Spark/Ray at scale, and the anti-patterns (no dedup, benchmark contamination, language-blind filtering, high-fertility tokenizers, no provenance) that waste compute and leak evals.
- ▌
- ▌ Accelerator Memory Estimator · sanjeevrg89 bundleUse this to ESTIMATE GPU/TPU memory for an ML workload and DECIDE what fits and what parallelism is needed. Trigger whenever someone asks "will this model fit", "do I have enough VRAM/HBM", "OOM / CUDA out of memory", "how many H100s / how much TPU HBM do I need", "what batch size fits", "can I fine-tune a 7B/70B on one GPU", "how big is the KV cache". Performs the actual arithmetic: training memory (weights + gradients + optimizer states + activations + overhead), sharding math (FSDP/ZeRO-1/2/3, tensor parallel, pipeline parallel), and inference KV-cache memory (with GQA/MQA). Given a model + config, it computes per-device memory, compares to capacity (H100 80GB, A100 40/80GB, TPU v5e/v5p HBM), and RECOMMENDS a fitting strategy (fits / FSDP / TP=k / activation checkpointing / quantization / QLoRA). All outputs are ESTIMATES (±) — verify against a real run.
- ▌ Kubernetes Controller Expert · sanjeevrg89 bundleWorld-class guidance for writing correct, production-grade Kubernetes controllers with controller-runtime (kubebuilder) and client-go. Use when authoring or reviewing a Reconciler, reconcile loop, informer/lister/workqueue code, finalizers, owner references, status conditions, server-side apply, leader election, or envtest/Ginkgo controller tests — anytime there are `.go` files importing `sigs.k8s.io/controller-runtime`, `k8s.io/client-go`, or `k8s.io/apimachinery`, a `Reconcile(ctx, req)` method, a `SetupWithManager`, a `main.go` wiring a `manager.Manager`, or symptoms like hot-loop reconciles, stuck finalizers, cache staleness races, requeue storms, or controllers fighting each other. Covers level-triggered reconciliation, the reflector→DeltaFIFO→indexer→workqueue flow, idempotent reconcile, `RequeueAfter`, GC via ownerReferences, `metav1.Condition` + observedGeneration, and scaling caches with selectors/indexes.
- ▌ Data Engineering Feature Stores · sanjeevrg89 bundleExpert data engineering for ML — the pipelines, feature stores, and data-quality discipline that decide whether models work in production ("garbage in, garbage out"). Use when building or debugging ML data pipelines (ingestion, validation, transformation, batch vs streaming), orchestration (Airflow, Dagster, Flyte, Spark, Beam), the lakehouse (Delta Lake, Apache Iceberg, Hudi, Parquet), or data versioning (DVC, LakeFS, lakeFS). Use for streaming & real-time features (Kafka/Pulsar, Flink, Spark Structured Streaming, Beam, CDC/Debezium, windowed aggregations, watermarks, late/out-of-order data, exactly-once, online/offline consistency) and real-time inference (fraud, recsys). Use for the analytics /query side — data warehouses (BigQuery, Snowflake, Redshift) and OLAP/lakehouse query engines (Spark SQL, Trino/Presto, DuckDB), columnar/partitioning/clustering and query cost, SQL for ML (window functions, point-in-time/as-of joins, cohorting), and dbt-style transformation/label/feature derivation. Use for feature
- ▌ Distributed Systems Fundamentals · sanjeevrg89 bundleThe timeless distributed-systems fundamentals every architect must reason from — the impossibility/tradeoff results (CAP, PACELC, FLP, the fallacies of distributed computing), consensus (Paxos, Raft leader election & log replication, ZAB/Viewstamped Replication, quorums), replication & consistency models (single/multi/leaderless, linearizability → causal → eventual, read-your-writes, R+W>N quorums, LWW/vector clocks/CRDTs), partitioning/consistent hashing, caching & stampede, queues & the log (at-least/exactly-once, idempotency, outbox), time & logical/vector/hybrid clocks, cross-node transactions (2PC, sagas, isolation levels, the dual-write problem), and failure/reliability (failure detectors, retries/backoff/jitter, fencing tokens, backpressure). Use when designing or reviewing any replicated, sharded, multi-region, or fault-tolerant system; choosing a consistency model; doing leader election or distributed locking; debugging split-brain, stale reads, lost updates, clock-skew bugs, duplicate processing, or
- ▌