Concepts
Browse published references and the topic map that connects them.
Concepts is for browsing: click any name to expand it in place — its summary, its facts count, its children — and keep going down without leaving this page. Each expanded topic offers read reference when it has published content and browse topicwhen it is a navigation entry. Topic entries without a reference stay available for browsing and are excluded from search indexing.Context files is the other tab: the same concept research as a shelf of facts files to load, sized in tokens.
A frontier name has no topic node of its own. The map derives these names from unresolved childConcepts and unchecked entries in the snapshotted research queue. Frontier names indicate work to investigate, not published references.How to read this.
1005 published references · 338 topic entries · 4340 frontier names · 11 roots · snapshot 2026-10-14 · 3D view
AI & LLM Engineering 6
Building with language models: agents, model internals, retrieval, prompting, skills, and research tooling.
Prompting & Agent Skills 3
Writing, optimizing, and finding prompts and Claude Code skills.
Prompt Helper and Optimizer ●
- Prompt Optimization Algorithms (frontier)
- APE and OPRO Methods (frontier)
- DSPy and MIPROv2 (frontier)
- Agent-Ready Prompt Writing (frontier)
Prompt Lookup ●
- Prompt Template Discovery (frontier)
- Prompt Search and Retrieval (frontier)
- Prompt Improvement (frontier)
Claude Code Skills ● 2
Claude Code Plugins ●
- Plugin Anatomy and Structure (frontier)
- Hook System (29 Events) (frontier)
- Plugin Commands and Skills (frontier)
- Agent Definitions (frontier)
- Plugin Distribution (frontier)
- Skill Authoring Best Practices (frontier)
- Skill Discovery and Distribution (frontier)
- Skill Management and Composition (frontier)
Skill Lookup ●
- Skill Discovery (frontier)
- Skill Installation (frontier)
- Skill Search Workflow (frontier)
Research & Knowledge Tooling 5
Deep research methods, llms.txt, and the Global AI Hub that stores what the research finds.
Deep Research ● 1
- Multi-Source Web Research (frontier)
- Firecrawl and Exa Integration (frontier)
- Cited Report Generation (frontier)
- Source Attribution (frontier)
Deep Research Methods ●
- Question Decomposition (frontier)
- Source Evaluation Heuristics (frontier)
- Multi-Source Synthesis (frontier)
- Subagent Research Patterns (frontier)
- Anti-Pattern Detection (frontier)
llms.txt and LLM-readable documentation 6
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms.txt specification v2
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms-full.txt page grammars
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms.txt generation tooling
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms.txt ecosystem evidence
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms.txt recreation and family aggregation
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms.txt and the AI-discovery standards family 7
llms.txt ●
NLWeb and MCP as agentic-discovery alternatives to llms.txt ●
Really Simple Licensing (RSL) ●
robots.txt and the Content-Signal AI-preference extension ●
agents.md and the Universal Commerce Protocol (UCP) ●
Cloudflare AI-crawler monetization & verification stack ●
EU AI Act Article 53(1)(c) TDM Opt-Out ●
Global Context Hub Architecture 4
Concept Tree Tracking 1
3D Force-Directed Graphs
Library Registries 4
MCP Server Library
Repo Scenarios Library
URL Reference Library
Shared Code Library
Execution and Telemetry 4
File Analysis and Logs
Agent and Role Bindings
Aider Persistent Memory Hooks
Stdlib-Only Python Architecture
Code and Prompts 2
Reusable Coding Patterns
Prompt Optimization and Variants
Global AI Hub Research Corpus
Document Extraction & Text Distillation 7
Turning web pages and documents into clean, deduplicated text for LLMs.
Extraction Evaluation Frameworks ●
Heuristic Boilerplate Removal & Text-Density Algorithms for Web Extraction ●
LlamaParse vs. Docling for LLM Ingestion ●
LLM Zero-Shot Data Extraction for Unstructured Text ●
Semantic vs Lexical Deduplication for Text Distillation ●
Text Canonicalization for Exact-Match Deduplication Prep ●
Vision-Language Model (VLM) Layout Parsing and Document Zoning ●
AI Agent Ecosystems ● 30
A2A Protocol Interoperability ● 2
7-State Task Lifecycle ●
AAIF and Protocol Governance ●
- Agent Cards (frontier)
- JSON-RPC 2.0 Transport (frontier)
- Cross-Framework Agent Bridging (frontier)
AI Datastores ●
- Vector Databases (frontier)
- Knowledge Graphs for AI (frontier)
- Agent Memory Frameworks (frontier)
- Redis for Agent Coordination (frontier)
- Hybrid Storage Architectures (frontier)
Agent Council ●
- Multi-AI Opinion Synthesis (frontier)
- Parallel Agent Querying (frontier)
- Consensus Building (frontier)
Agent Harness Construction ●
- Action Space Design (frontier)
- Observation Format Design (frontier)
- Error Recovery Contracts (frontier)
- Context Budget Management (frontier)
Agent Plan Writing ●
- Multi-Agent Orchestration Planning (frontier)
- Subagent Prompt Crafting (frontier)
- Context Window Budgeting (frontier)
- Safety Guardrails Design (frontier)
- Agent Evaluation Planning (frontier)
Autonomous Loop Patterns ●
- Sequential Pipeline Patterns (frontier)
- Infinite Agent Loops (frontier)
- RFC-Driven DAG Orchestration (frontier)
- NanoClaw REPL (frontier)
Multi-Agent Workflow Builder
- Microsoft Agent Framework (frontier)
- Agent Tracing and Monitoring (frontier)
- Agent Evaluation (frontier)
- Foundry Deployment (frontier)
Agent Runtime Sandboxes & Code Execution ●
- MicroVM vs gVisor vs container isolation (frontier)
- Sandbox lifecycle (create/exec/dispose) (frontier)
- Pause-resume & memory snapshots (frontier)
- Filesystem snapshots & declarative images (frontier)
- Sandbox forking (copy-on-write branching) (frontier)
- Network egress policy (default-deny, allow-lists) (frontier)
- The lethal trifecta & prompt-injection exfiltration (frontier)
- Dual-LLM & CaMeL capability-based mitigation (frontier)
- Code Mode / programmatic tool calling (frontier)
- MCP-in-a-sandbox (gateways, credential brokering) (frontier)
- GPU sandboxes for ML agents (frontier)
- Built-in vs standalone vs BYOC sandboxes (frontier)
Durable Agent Execution & Long-Running Agent Runtimes ● 1
- Deterministic replay & event sourcing (frontier)
- Workflow-as-code / durable functions (frontier)
Checkpointing & state persistence ●
- Human-in-the-loop interrupts & resume (frontier)
- Activities vs workflow body (non-determinism isolation) (frontier)
- Time-travel debugging & workflow forking (frontier)
- Durable sleep, timers & cron scheduling (frontier)
- Exactly-once side effects & idempotency (frontier)
- Durable actors & hibernation (Durable Objects) (frontier)
- Durable queues & concurrency flow control (frontier)
- Durable streams (reconnectable agent output) (frontier)
- Postgres-backed vs orchestrator-based durability (frontier)
Agent Identity, Authorization & Payments ●
- Non-human identity (NHI) for agents (frontier)
- OAuth 2.1 on-behalf-of / token exchange (RFC 8693) (frontier)
- Scoped least-privilege short-lived agent tokens (frontier)
- MCP authorization & resource-server pattern (RFC 9728/8707) (frontier)
- Token vaulting & credential brokering (frontier)
- Human-in-the-loop consent & async authorization (frontier)
- Confused-deputy & prompt-injection authority hijack (frontier)
- Delegation chains & act/may_act claims (frontier)
- AP2 mandates (Intent / Checkout / Payment, SD-JWT) (frontier)
- x402 HTTP-402 stablecoin settlement (frontier)
- Agentic Commerce Protocol & delegated payment / Shared Payment Token (frontier)
- Spend caps, allowances & agent payment audit trails (frontier)
Dmux Multi-Agent Workflows
- Tmux Pane Manager for Agents (frontier)
- Parallel Agent Coordination (frontier)
- Multi-Harness Orchestration (frontier)
- Agent Workflow Patterns (frontier)
LLM Observability ●
- LLM/agent tracing and spans (frontier)
- OpenTelemetry GenAI semantic conventions (frontier)
- OpenInference span-kind standard (frontier)
- OpenLLMetry / Traceloop instrumentation (frontier)
- Token, cost, and latency monitoring (frontier)
- Online (reference-free) evaluation vs offline eval (frontier)
- LLM-as-judge production scoring (frontier)
- Hallucination / groundedness / faithfulness monitoring (frontier)
- Answer-relevance monitoring (frontier)
- Prompt / output / embedding drift detection (frontier)
- Runtime guardrails and safety monitoring (frontier)
- PII detection and redaction at runtime (frontier)
- RAG observability (RAGAS: context precision/recall, faithfulness) (frontier)
- Agent trajectory and tool-call observability (frontier)
- Loop / recursion detection in agents (frontier)
- Prompt management and versioning (frontier)
- Datasets and experiment tracking (frontier)
- Observability tooling landscape (Langfuse, LangSmith, Arize Phoenix, WhyLabs/LangKit, Helicone, Datadog, OpenLLMetry) (frontier)
Multi-Agent Orchestration Topologies ●
- Orchestrator-Worker (Supervisor) (frontier)
- Hierarchical Agents (frontier)
- Network / Peer-to-Peer (frontier)
- Sequential & Parallel Pipelines (frontier)
- Handoff / Swarm (frontier)
- Group Chat (AutoGen / Magentic-One) (frontier)
- Blackboard Architecture (frontier)
- Single-Agent vs Multi-Agent Decision (frontier)
- Role Specialization & Decomposition (frontier)
- Shared vs Isolated Context (frontier)
Agent Planning & Control-Flow Patterns ●
- ReAct (reason+act interleaving) + failure modes (frontier)
- Plan-and-Execute / Plan-and-Solve (frontier)
- ReWOO (reasoning without observation) (frontier)
- LLMCompiler (parallel function-call DAG) (frontier)
- Reflexion / Self-Refine + the intrinsic-self-correction caveat (frontier)
- Tree/Graph-of-Thoughts applied to acting (LATS) (frontier)
- Workflows vs Agents + the 5 Anthropic workflow patterns (frontier)
- Task decomposition & replanning on failure (frontier)
Agent State & Durable Execution ●
- LangGraph StateGraph (channels, reducers, super-steps) (frontier)
- Checkpointing & thread_id persistence (frontier)
- Human-in-the-loop interrupts & time-travel/replay/fork (frontier)
- Durable execution engines (Temporal, Restate, DBOS, Inngest) (frontier)
- Checkpointing != durable execution (frontier)
- Determinism constraint & idempotency keys (frontier)
- Architecture spectrum & LangGraph-in-Temporal use-both (frontier)
- LangGraph durability modes (exit/async/sync) (frontier)
Agent Reliability & Guardrails ● 1
- Input/Output Guardrails (frontier)
- Structured-Output Validation (frontier)
- Content Filters & Safety Classifiers (Llama Guard / NeMo Guardrails / Guardrails AI) (frontier)
- Reliability Patterns (Retries, Backoff, Circuit Breakers, Fallback Chains) (frontier)
- Budget & Step Caps (frontier)
Loop & No-Progress Detection ●
- Tool-Call Safety (Sandboxing, Allow-lists, Least Privilege) (frontier)
- Human-Approval Gates (frontier)
- Excessive Agency (OWASP LLM06) (frontier)
- Prompt Injection & Indirect Prompt Injection (OWASP LLM01) (frontier)
- The Lethal Trifecta (frontier)
- Tool / RAG Poisoning (frontier)
- OWASP Top 10 for LLM Applications (frontier)
- Dual-LLM / Quarantine & CaMeL Defenses (frontier)
- Constrained Agent Design Patterns (frontier)
Computer-Use & GUI Agents ●
- Computer-use agents (Claude computer use, OpenAI Operator/CUA) (frontier)
- Browser agents (Browser Use, Playwright/CDP) (frontier)
- GUI grounding (pixel vs accessibility tree vs set-of-marks) (frontier)
- Screen parsers (OmniParser) (frontier)
- GUI action space (click/type/scroll/key) (frontier)
- Computer-use benchmarks (OSWorld, WebArena, WebVoyager, Mind2Web, AndroidWorld) (frontier)
- GUI agent reliability ceilings (frontier)
- Computer-use safety (prompt injection via screen, destructive clicks, sandboxing) (frontier)
Agent Memory Architecture ● 1
- Memory Types (Working/Episodic/Semantic/Procedural) (frontier)
- CoALA Cognitive Architecture (frontier)
- Short-term vs Long-term Memory Management (frontier)
Context-Window Pressure & Compaction ●
- Memory Extraction & Retrieval Policies (frontier)
- Forgetting & Decay (frontier)
- MemGPT / Letta Virtual Context Paging (frontier)
- Self-Editing Memory (frontier)
- Reflection & Memory Consolidation (frontier)
- Generative Agents (observe-reflect-plan) (frontier)
- Memory Frameworks (Mem0 / Zep-Graphiti / LangMem) (frontier)
- Temporal Knowledge Graph Memory (frontier)
- Memory vs RAG (frontier)
- Hallucinated Memories (frontier)
- Memory Evaluation (LoCoMo / LongMemEval) (frontier)
LLM Model Routing, Cascades & Mixture-of-Agents ●
- Predictive routing (RouteLLM router taxonomy, PGR/CPT) (frontier)
- Route-by-difficulty / complexity (Route-to-Reason, RADAR, think-vs-non-think) (frontier)
- Model cascades + deferral/abstention (FrugalGPT, threshold calibration) (frontier)
- Speculative cascades (token-level deferral, vs speculative decoding) (frontier)
- Mixture-of-Agents (MoA layered proposers + aggregator) (frontier)
- Output ensembling & fusion (LLM-Blender PairRanker + GenFuser) (frontier)
- Semantic / prompt caching as a routing layer (GPTCache) (frontier)
- Cost/quality/latency Pareto modeling (frontier)
- Router evaluation & benchmarks (RouterBench, AIQ, RouterArena) (frontier)
- Routing tooling landscape (OpenRouter, LiteLLM, NotDiamond, Martian, vLLM Semantic Router) (frontier)
- Failure modes (routing collapse, tail miscalibration) (frontier)
Agentic and Advanced RAG Patterns ●
- Naive-RAG failure taxonomy (Barnett 7 points, lost-in-the-middle) (frontier)
- Query transformation (HyDE, decomposition, step-back, RAG-Fusion+RRF) (frontier)
- Hybrid search & re-ranking (BM25+dense, cross-encoders, ColBERT, MMR) (frontier)
- Advanced indexing (parent-doc, sentence-window, auto-merging, Anthropic Contextual Retrieval) (frontier)
- Agentic RAG (Self-RAG, CRAG, Adaptive-RAG, iterative, routing) (frontier)
- GraphRAG (Microsoft, Leiden communities, hybrid graph+vector) (frontier)
- RAG evaluation (Ragas, retrieval-vs-generation split) (frontier)
- Multimodal RAG (ColPali) + long-context-vs-RAG routing (frontier)
AI Red-Teaming and Security-Testing Tooling ●
- Open-source scanners/frameworks (Garak, PyRIT, promptfoo, Giskard, CyberSecEval) (frontier)
- Attack taxonomy (direct/indirect injection, jailbreak families, many-shot, Crescendo, exfiltration) (frontier)
- Automated attack generation (GCG, PAIR, TAP, red-teamer LLMs) (frontier)
- Benchmarks (AdvBench, HarmBench, JailbreakBench, AgentDojo) (frontier)
- Commercial continuous red-teaming (Lakera/Gandalf, Cisco AI Defense, Mindgard) (frontier)
- Process & governance (OWASP GenAI Red Teaming Guide, MITRE ATLAS, NIST AI RMF, red-team-in-CI) (frontier)
Voice and Real-Time Agent Design ●
- Cascaded vs speech-to-speech architecture (frontier)
- Real-time APIs (OpenAI Realtime gpt-realtime, Gemini Live) (frontier)
- Turn detection & barge-in (VAD, semantic, Deepgram Flux, backchannel) (frontier)
- Voice latency budgeting (<800ms, LLM TTFT ~70%) (frontier)
- Streaming STT/TTS components (Deepgram, ElevenLabs, Cartesia) (frontier)
- Orchestration & telephony (LiveKit, Pipecat, Vapi/Retell/Bland, SIP) (frontier)
- Voice UX (confidence-tiered confirmation, error recovery, consent) (frontier)
- Voice-agent evaluation (4-layer, WER limits, interruption accuracy, MOS, TSR/FCR) (frontier)
Declarative and Programmatic LLM Frameworks ●
- Compiled/optimized prompting (DSPy signatures/modules/compile) (frontier)
- Schema-first typed LLM functions (BAML + Schema-Aligned Parsing, codegen) (frontier)
- Constrained generation/decoding (Outlines FSM, Guidance token-healing, LMQL) (frontier)
- Type/validation structured-output libs (Instructor, Pydantic AI, Mirascope) (frontier)
- App-level structured output (strict mode, function-calling-as-extraction, validate+reask) (frontier)
- Test-driven & versioned prompting (frontier)
- When-declarative-wins decision & anti-patterns (frontier)
AI Coding-Agent Design ●
- Repo-map & structural code indexing (tree-sitter + PageRank) (frontier)
- Semantic code retrieval & AST-aware chunking (cAST, Cursor/Merkle) (frontier)
- Agentic grep vs precomputed-index retrieval (the central debate) (frontier)
- Edit/diff application formats & reliability (udiff vs search-replace, lint-gated) (frontier)
- Agent-Computer Interface (ACI) & CodeAct action space (frontier)
- Test-driven control loops & self-repair (plan-edit-test-repair, SBFL) (frontier)
- Agentless / structured SWE pipelines (localize-repair-validate) (frontier)
- Context management for long-horizon code agents (frontier)
- Benchmarks (SWE-bench family, Aider polyglot, Terminal-Bench) (frontier)
Eval-Driven Development for LLM Apps ● 1
- Error analysis & qualitative coding (open/axial coding of traces) (frontier)
- The Three Gulfs (Specification/Generalization/Comprehension) (frontier)
- Criteria drift & Who-Validates-the-Validators (EvalGen, SPADE) (frontier)
- Eval levels (assertion / LLM-as-judge / human; offline vs online flywheel) (frontier)
LLM-as-judge bias & calibration (kappa, binary-vs-Likert, position/verbosity/self-preference) ●
- Golden datasets & synthetic eval-data (silver-to-gold) (frontier)
- Metric design (rubric, pairwise, pass@k vs pass^k) (frontier)
- CI/CD eval gating & regression suites (frontier)
- Agent/trajectory evaluation (frontier)
- Tooling (promptfoo, DeepEval, Ragas, Braintrust, LangSmith) (frontier)
LLM Context Engineering ● 1
Instruction-file hygiene for LLM lexical tics: linting, mirroring, hook filtering
- Anti-laziness prompt legacy (frontier)
- Classifying hits: ban list vs example vs prose (frontier)
- Emphatic language in prompts and overtriggering (frontier)
- Few-shot example style leakage (frontier)
- Fixed prompt-set regression harness for style (frontier)
- Hook-based filtering of agent output (frontier)
- Linting instruction files for seeded vocabulary (frontier)
- Negative instructions vs positive framing (frontier)
- Per-model prompt migration (frontier)
- Positive framing of format instructions (frontier)
- PostToolUse updatedToolOutput (frontier)
- Prompt-format mirroring and structural priming in output (frontier)
- Stop hook nag-once pattern (frontier)
- Synonym substitution after word bans (frontier)
- Tic-word list curation per model (frontier)
- Verifying a vocabulary fix with before-and-after tic rates (frontier)
- Context-as-managed-resource / RAM framing (Karpathy LLM-as-OS) (frontier)
- Context rot / lost-in-the-middle / effective-vs-advertised length (NoLiMa, RULER) (frontier)
- Compaction & context editing (auto-compact ~95%, Claude memory tool) (frontier)
- Just-in-time / agentic retrieval vs pre-loading (frontier)
- External memory & filesystem-as-memory (recoverable compression) (frontier)
- Multi-agent context (shared traces vs isolation: Cognition vs Anthropic) (frontier)
- KV-cache-aware layout (stable prefix, append-only, mask tools) (frontier)
- Failure modes (poisoning/distraction/confusion/clash - Breunig) (frontier)
LLM Inference Optimization and Serving ●
- Serving-engine landscape (vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy, NVIDIA Dynamo) (frontier)
- PagedAttention and KV-cache memory management (+ KV offload: LMCache/KVBM/FlexKV) (frontier)
- Continuous / in-flight batching (frontier)
- Chunked prefill and the vLLM V1 unified scheduler (frontier)
- Prefix / prompt caching (Automatic Prefix Caching, RadixAttention) (frontier)
- Prefill/decode disaggregation (DistServe, Splitwise, KV-aware routing) (frontier)
- Latency/throughput metrics and SLOs (TTFT, TPOT/ITL, goodput) (frontier)
- Multi-GPU inference (tensor / pipeline / expert parallelism) (frontier)
- Constrained / structured decoding at serving layer (XGrammar, Outlines, llguidance) (frontier)
- Speculative decoding (draft models, Medusa, lookahead, EAGLE/EAGLE-2/EAGLE-3) (frontier)
- Endpoint autoscaling and cost-per-token (KEDA/Knative, scale-to-zero) (frontier)
LLM agent architecture and orchestration
Algorithmic Discovery & Superoptimization
- Superoptimization & complexity reduction (STOKE, Souper, Massalin origins) (frontier)
- Program-synthesis & evolutionary substrate (sketching, CEGIS, SyGuS, GenProg) (frontier)
- AlphaTensor — TensorGame for matrix multiplication (frontier)
- AlphaDev — AssemblyGame for sorting/hashing (frontier)
- FunSearch — LLM proposer + systematic evaluator (frontier)
- AlphaEvolve — the evolutionary coding-agent keystone (frontier)
- Open descendants & sample-efficiency frontier (ShinkaEvolve, OpenEvolve) (frontier)
- LLM + formal-verifier hybrids for classical optimization (LPO) (frontier)
- ML-guided compiler optimization & autotuning (MLGO, OpenTuner, Halide) (frontier)
- Provable vs measured trust (frontier)
Aider in Open-Source Agentic Coding with Ollama ●
LLM Models and APIs ● 24
AI Programming Languages ●
- Python AI Frameworks (frontier)
- TypeScript AI Frameworks (frontier)
- Rust AI Frameworks (frontier)
- Go AI Frameworks (frontier)
- Prompt Engineering Languages (frontier)
LLM Integration Patterns
- LLM Integration Review Workflow (frontier)
- Prompt Injection Defense (frontier)
- Structured Output Patterns (frontier)
- Caching and Cost Control (frontier)
LLM Alignment and Post-Training ● 1
Why LLMs converge on the same words: mode collapse and post-training lexical effects
- Annotator dialect hypothesis (frontier)
- Annotator dialect hypothesis for 'delve' (frontier)
- Attractor states in aligned models (frontier)
- Base-model vs aligned-model sampling (frontier)
- Distillation as a homogeneity confounder (frontier)
- Diversity-restoring decoding and prompting (frontier)
- Human-feedback emulation experiments (frontier)
- Infinity-Chat benchmark (frontier)
- Inter-model homogeneity in open-ended generation (frontier)
- KL-regularised optimal policy sharpening (frontier)
- Markdown and em-dash fingerprinting (frontier)
- Markdown and em-dash fingerprints (frontier)
- Mode collapse and typicality bias in preference tuning (frontier)
- Post-training effects on LLM vocabulary (frontier)
- Preference-stage lexical shift metrics (frontier)
- Pretraining versus alignment attribution of lexical tics (frontier)
- Temperature and truncation sampler tuning (frontier)
- Supervised Fine-Tuning / Instruction Tuning (frontier)
- Reward Modeling (Bradley-Terry, RewardBench) (frontier)
- RLHF with PPO (KL penalty, value model) (frontier)
- RLAIF (AI feedback) (frontier)
- Constitutional AI / RLCAI (frontier)
- DPO (Direct Preference Optimization) (frontier)
- DPO-Variant Family (IPO/KTO/ORPO/SimPO/CPO) (frontier)
- Preference-Data Pipelines (pairwise/ratings, on/off-policy, iterative/self-rewarding) (frontier)
- Reward Hacking / Length Bias / Over-Optimization (frontier)
- Alignment Evaluation (win-rate, LC-AlpacaEval, Arena-Hard, RewardBench, safety) (frontier)
- Alignment Tooling (TRL, alignment-handbook, Axolotl, OpenRLHF) (frontier)
LLM Compression (Quantization, Distillation, Pruning, Merging) ●
- PTQ vs QAT (frontier)
- GPTQ (frontier)
- AWQ (frontier)
- SmoothQuant (W8A8 activation quant) (frontier)
- GGUF llama.cpp k-quants & imatrix (frontier)
- bitsandbytes NF4 & LLM.int8 (frontier)
- FP8/INT4 & MX/MXFP4 microscaling (frontier)
- KV-cache quantization (KIVI/KVQuant) (frontier)
- BitNet & EfficientQAT (frontier)
- Knowledge distillation (logit/feature/sequence/on-policy GKD/MiniLLM/DistiLLM) (frontier)
- Pruning & sparsity (SparseGPT, Wanda, 2:4 N:M) (frontier)
- Model merging (TIES/DARE/SLERP/task-arithmetic/soups/MergeKit) (frontier)
- Compressed-model evaluation (perplexity vs KL vs flips) (frontier)
Reasoning Models and Test-Time Compute ●
- Chain-of-thought and long-CoT (frontier)
- Reinforcement learning for reasoning (GRPO + DeepSeek-R1/R1-Zero recipe) (frontier)
- RLVR — reinforcement learning with verifiable rewards (frontier)
- Process reward models (PRM) vs outcome reward models (ORM) and process supervision (frontier)
- Parallel test-time compute (self-consistency / majority vote, best-of-N, generative verifiers) (frontier)
- Search-based test-time compute (beam, lookahead, MCTS, reward-guided decoding) (frontier)
- Inference-time scaling laws and compute-optimal test-time scaling (frontier)
- The o-series / R1-class reasoning-model landscape (frontier)
- Budget forcing and thinking-token control (frontier)
- Reasoning distillation (R1-Distill) (frontier)
- Reasoning benchmarks (AIME, GPQA-Diamond, MATH, LiveCodeBench) (frontier)
- Cost / latency / accuracy trade-offs and overthinking (frontier)
Distributed Training & Training Infrastructure ● 1
3D/ND parallelism composition (TP×PP×CP×EP×DP placement) + expert parallelism ●
- Data parallelism & PyTorch DDP (gradient bucketing, backward/comm overlap) (frontier)
- ZeRO optimizer stages 1/2/3 + ZeRO-Offload/ZeRO-Infinity (frontier)
- FSDP & FSDP2 (FlatParameter→per-parameter DTensor, HSDP) (frontier)
- Tensor parallelism (Megatron column/row split) + sequence parallelism (frontier)
- Pipeline parallelism (GPipe, 1F1B, interleaved, the bubble, Seq1F1B/DualPipe) (frontier)
- Context/sequence parallelism for long context (Ring Attention, DeepSpeed-Ulysses, USP) (frontier)
- Mixed precision (FP16 vs BF16 vs FP8/Transformer-Engine, loss scaling) (frontier)
- Gradient checkpointing / selective activation recomputation & gradient accumulation (frontier)
- Collective communication (NCCL all-reduce/all-gather/reduce-scatter/all-to-all, ring vs tree, overlap) (frontier)
- Training stability (loss spikes, z-loss, QK-norm, LR warmup, init, grad clip/ZClip) (frontier)
- Distributed checkpointing (PyTorch DCP sharded + async, resharding) (frontier)
- Frameworks (torchtitan, Megatron-Core, DeepSpeed, NeMo, Composer) & MFU/HFU scaling efficiency (frontier)
LLM Pretraining & Scaling Laws ●
- Pretraining objectives (causal/autoregressive LM, masked LM, prefix-LM, FIM, UL2 mixture-of-denoisers) (frontier)
- Pretraining data pipeline (web curation, MinHash/LSH dedup, quality filtering, FineWeb/FineWeb-Edu) (frontier)
- Data mixtures & domain weighting (DoReMi Group-DRO proxy reweighting) (frontier)
- Tokenizer training (vocab size ~128K, fertility/parity) & eval-set decontamination (frontier)
- Kaplan vs Chinchilla compute-optimal scaling (N∝C^0.5, ~20 tokens/param) & reconciliation (frontier)
- Data-constrained scaling (Muennighoff, ≤4 epochs) & inference-aware / over-training (Sardana & Frankle) (frontier)
- The C≈6ND compute budget (2N forward + 4N backward, MoE active-params, MFU) (frontier)
- Emergent abilities & the mirage debate (Wei vs Schaeffer) (frontier)
- LR schedules at scale (cosine vs Warmup-Stable-Decay/WSD, MiniCPM) & data annealing (frontier)
- Continual & domain-adaptive pretraining (LR re-warm + re-decay + replay) (frontier)
- Base-model (pre-instruct) evaluation (perplexity, few-shot log-likelihood, lm-evaluation-harness) (frontier)
Multimodal & Vision-Language Model Architecture ● 1
Vision-Model / Multimodal-LLM Design Critique Technique
- VLM-as-judge / MLLM-as-judge calibration vs human designers (rank-not-score, pairwise>pointwise) (frontier)
- Rubric-based visual critique prompting (describe-then-judge, rubric-as-prompt, supplied definitions) (frontier)
- Structured/JSON findings output (json_schema/responseSchema/tool-use; the format tax — reason-first) (frontier)
- Region grounding of findings (Set-of-Mark, OmniParser OCR+icon pre-pass, points>boxes) (frontier)
- Multi-image & before/after comparison (image labeling, image-order/position bias, order-swap) (frontier)
- Object/element hallucination in critique (POPE/AMBER/MMHal, co-occurrence & affirmative bias) (frontier)
- Weak fine-grained spatial reasoning & counting (VSR/BLINK/SpatialEval/CountBench) (frontier)
- Text-in-image / OCR limits in UI critique (OCRBench, resolution/detail param, external OCR pre-pass) (frontier)
- Judge biases: position, verbosity, self-preference, sycophancy (sycophantic modality gap) (frontier)
- Reliability practices (few-shot anchors, self-consistency, LLM-as-jury panels, abstention, temp 0) (frontier)
- Vision encoders (ViT/CLIP/SigLIP/DINOv2/EVA) (frontier)
- Modality connector/projector (MLP/Q-Former/gated cross-attention) (frontier)
- Fusion strategies (unified-concat vs cross-attention vs late) (frontier)
- Native any-to-any & image tokenization (Chameleon VQ-VAE, Fuyu) (frontier)
- High-resolution & dynamic tiling (AnyRes/NaViT/native-resolution ViT) (frontier)
- Audio/video/speech modalities (Whisper encoder, Thinker-Talker, frame sampling) (frontier)
- Multimodal position encoding (2-D RoPE, M-RoPE) (frontier)
- VLM training stages (projector-align, visual instruction tuning, multimodal DPO) (frontier)
- The VLM model landscape (LLaVA/Qwen-VL/InternVL/Pixtral/Llama-3.2-Vision/Chameleon/GPT-4o) (frontier)
- Multimodal benchmarks & hallucination (MMMU/MMBench/DocVQA/MathVista/POPE/MMHal) (frontier)
Agentic RL — Reinforcement Learning for LLM Agents ●
- Multi-turn / long-horizon RL & the POMDP framing (vs single-step PBRFT MDP) (frontier)
- Long-horizon temporal credit assignment (trajectory-level vs step-level advantage) (frontier)
- Agentic RLVR — verifiable rewards from environment outcomes (code/tests, task/search success) (frontier)
- RL environments & gyms and the step/reset/state interface (OpenEnv, SkyRL-Gym, RAGEN, BrowserGym) (frontier)
- Reward design & long-horizon reward hacking (outcome vs process, sparse vs dense, the Echo Trap) (frontier)
- GRPO/PPO adapted to multi-turn — observation/tool-token masking (retrieved-token masking) (frontier)
- Trajectory-level StarPO/StarPO-S and nested episode+step GiGPO credit assignment (frontier)
- Rollout infrastructure for agentic RL (async server-based vLLM/SGLang, actor-learner, verl AgentLoop, SkyRL-Agent) (frontier)
- Tool-use RL / agent-as-policy (ReTool, ToRL, tool-integrated reasoning) (frontier)
- The 2025-26 agentic-RL model wave (Kimi-Researcher, search/SWE/computer-use agents) (frontier)
- Agent RL benchmarks (SWE-bench Verified, WebArena, tau-bench/tau2-bench pass^k, GAIA, OSWorld, AppWorld, Terminal-Bench) (frontier)
Mechanistic Interpretability ●
- Superposition & polysemanticity (linear representation hypothesis) (frontier)
- Sparse autoencoders & dictionary learning (Gated/TopK/JumpReLU, Gemma Scope) (frontier)
- The SAE critique wave (random-Transformer baselines, non-canonical, deprioritization) (frontier)
- Transcoders & cross-layer transcoders/crosscoders (frontier)
- Circuit discovery (induction heads, IOI, activation/path patching, ACDC, EAP) (frontier)
- Sparse feature circuits (frontier)
- Attribution graphs & circuit tracing (Biology of an LLM) (frontier)
- Logit lens / tuned lens / linear probes / concept erasure (frontier)
- Activation steering & representation engineering (RepE, ActAdd) (frontier)
- Auto-interpretability & evaluation (SAEBench, Neuronpedia) (frontier)
- Tooling (TransformerLens, SAELens, nnsight/NDIF, Neuronpedia, Gemma Scope) (frontier)
- Interpretability for alignment & safety (auditing, deception probes, the interpretability illusion) (frontier)
Diffusion & Generative-Media Models ●
- Denoising diffusion core (DDPM, ε/v-prediction, noise schedules) (frontier)
- Score-based SDE/ODE view (VP/VE, probability-flow ODE, EDM/Karras) (frontier)
- Latent diffusion (VAE + denoiser, Stable Diffusion) (frontier)
- Architectures: UNet → Diffusion Transformer (DiT, MMDiT/SD3, FLUX) (frontier)
- Flow matching & rectified flow (conditional FM, stochastic interpolants, Diff2Flow) (frontier)
- Classifier-free guidance (CFG, guidance scale, negative prompts) (frontier)
- Samplers/schedulers (DDIM, DPM-Solver++, Euler/Heun, Karras sigmas) (frontier)
- Few-step generation & distillation (consistency models, LCM, ADD/Turbo, sCM, TurboDiffusion) (frontier)
- Conditioning & control (ControlNet, T2I-Adapter, IP-Adapter, DreamBooth, LoRA, textual inversion) (frontier)
- Text-to-video & video diffusion (spatiotemporal DiT, Sora/Veo/Kling/CogVideoX/Wan, temporal consistency) (frontier)
- Audio/music & other-modality diffusion (overview) (frontier)
- Evaluation & efficiency (FID/FVD/CLIPScore, VBench, efficiency surveys) (frontier)
AI Gateways & LLM Proxy Infrastructure ● 1
- Unified OpenAI-compatible API surface (frontier)
- Virtual keys & key-vault management (BYOK) (frontier)
- Rate limiting & quotas (frontier)
- Budget/spend controls & cost attribution/chargeback (frontier)
- Fallback chains, retries & load balancing (frontier)
- Gateway caching (exact-match vs semantic) (frontier)
- Guardrail & PII/DLP enforcement at the proxy (frontier)
- Observability, logging & tracing hooks (frontier)
- Governance, RBAC & audit (frontier)
- Self-hosted vs managed vs edge vs platform-native (frontier)
- Streaming (SSE) pass-through (frontier)
- MCP/agent/tool-call gateway governance (frontier)
LiteLLM gateway and SDK engineering 8
LiteLLM gateway and SDK engineering: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- Anthropic Messages native passthrough (frontier)
- Anthropic block fidelity and provider capabilities (frontier)
- Anthropic-to-Chat client tool translation (frontier)
- Anthropic-to-Responses routing (frontier)
- Context and thinking controls across local API surfaces (frontier)
- Endpoint-specific streaming failover (frontier)
- LiteLLM A2A agent gateway (frontier)
LiteLLM Anthropic Messages interoperability ●
LiteLLM Anthropic Messages interoperability: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- Anthropic Messages native passthrough (frontier)
- Anthropic block fidelity and provider capabilities (frontier)
- Anthropic-to-Chat client tool translation (frontier)
- Anthropic-to-Responses routing (frontier)
- LiteLLM MCP permission governance (frontier)
- LiteLLM OpenTelemetry generations and privacy (frontier)
- LiteLLM Responses API interoperability (frontier)
- LiteLLM Rust gateway migration (frontier)
- LiteLLM SDK exception taxonomy (frontier)
LiteLLM SDK provider normalization ●
LiteLLM SDK provider normalization: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- LiteLLM SDK exception taxonomy (frontier)
- LiteLLM model capability metadata (frontier)
- LiteLLM native finish reason preservation (frontier)
- LiteLLM unsupported parameter policy (frontier)
- LiteLLM budget reservation and reconciliation (frontier)
- LiteLLM cooldown policies (frontier)
- LiteLLM database-free deployment boundaries (frontier)
- LiteLLM distributed counter failure policy (frontier)
- LiteLLM exact cache identity and tenant namespace (frontier)
- LiteLLM gateway alias configuration (frontier)
LiteLLM local Ollama and OpenAI-compatible backends ●
LiteLLM local Ollama and OpenAI-compatible backends: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- Context and thinking controls across local API surfaces (frontier)
- LiteLLM native Ollama Chat adapter (frontier)
- Local function-tool capability qualification (frontier)
- OpenAI-compatible local server configuration (frontier)
- LiteLLM migrations and image provenance (frontier)
- LiteLLM model capability metadata (frontier)
- LiteLLM model groups and deployment selection (frontier)
- LiteLLM native Ollama Chat adapter (frontier)
- LiteLLM native finish reason preservation (frontier)
LiteLLM observability and caching ●
LiteLLM observability and caching: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- LiteLLM OpenTelemetry generations and privacy (frontier)
- LiteLLM exact cache identity and tenant namespace (frontier)
- LiteLLM semantic replay correctness for agents (frontier)
- Provider usage normalization with cached tokens (frontier)
- Redis cache expiration eviction and ACLs (frontier)
- LiteLLM passthrough endpoint capability parity (frontier)
LiteLLM proxy deployment and configuration ●
LiteLLM proxy deployment and configuration: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- LiteLLM database-free deployment boundaries (frontier)
- LiteLLM gateway alias configuration (frontier)
- LiteLLM migrations and image provenance (frontier)
- LiteLLM readiness and provider health (frontier)
- LiteLLM readiness and provider health (frontier)
- LiteLLM retry ownership and budgets (frontier)
LiteLLM routing retries and fallbacks ●
LiteLLM routing retries and fallbacks: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- Endpoint-specific streaming failover (frontier)
- LiteLLM cooldown policies (frontier)
- LiteLLM model groups and deployment selection (frontier)
- LiteLLM retry ownership and budgets (frontier)
- LiteLLM semantic replay correctness for agents (frontier)
- LiteLLM stream compatibility fixtures (frontier)
- LiteLLM streamed argument assembly (frontier)
- LiteLLM tenant authorization and key lifecycle (frontier)
LiteLLM tool calls and SSE streaming ●
LiteLLM tool calls and SSE streaming: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- LiteLLM stream compatibility fixtures (frontier)
- LiteLLM streamed argument assembly (frontier)
- LiteLLM tool result correlation (frontier)
- LiteLLM usage and stream termination (frontier)
- LiteLLM tool result correlation (frontier)
- LiteLLM unsupported parameter policy (frontier)
- LiteLLM usage and stream termination (frontier)
LiteLLM virtual keys budgets and rate limits ●
LiteLLM virtual keys budgets and rate limits: source-qualified SDK/gateway guidance; source confidence and deployment limits retained.
- LiteLLM budget reservation and reconciliation (frontier)
- LiteLLM distributed counter failure policy (frontier)
- LiteLLM tenant authorization and key lifecycle (frontier)
- Provider-specific token and spend accounting (frontier)
- Local function-tool capability qualification (frontier)
- OpenAI-compatible local server configuration (frontier)
- Provider usage normalization with cached tokens (frontier)
- Provider-specific token and spend accounting (frontier)
- Redis cache expiration eviction and ACLs (frontier)
On-Device & Local LLM Runtimes ● 5
- Ollama Modelfile & local model library (frontier)
- llama.cpp / llama-server & the GGUF format (frontier)
- GBNF grammars & local schema-constrained decoding (frontier)
- Apple MLX & MLX-LM (unified-memory inference) (frontier)
- LM Studio (GUI + SDK + MLX backend) (frontier)
- MLC-LLM & MLCEngine (universal/compiled deploy) (frontier)
- WebLLM & Transformers.js (WebGPU in-browser inference) (frontier)
- Chrome Built-in AI / Gemini Nano Prompt API (frontier)
- Apple Foundation Models framework & @Generable guided generation (frontier)
- Windows AI Foundry / Foundry Local & on-device NPU inference (frontier)
- Mobile on-device runtimes (MediaPipe to LiteRT-LM, ONNX Runtime GenAI / QNN) (frontier)
- Local hardware sizing & quant-level selection (RAM/VRAM, KV cache, Q4/Q5/Q8) (frontier)
Local LLM deployment economics and tooling
- Ollama (llama.cpp engine since 0.30, Modelfile, library) (frontier)
- llama.cpp / llama-server and GGUF (semver, --load-mode, router mode, MCP tools) (frontier)
- GBNF grammars and JSON-schema structured output (frontier)
- LM Studio and llmster headless daemon (frontier)
- vLLM and SGLang on a single consumer GPU (frontier)
- Jan, LocalAI, KoboldCpp, llamafile, Docker Model Runner, RamaLama (frontier)
- Apple MLX, mlx-lm, mlx-vlm (frontier)
Apple Foundation Models framework ●
- WebLLM and Transformers.js (frontier)
- Chrome Built-in AI / Gemini Nano and Edge Prompt API (frontier)
- MLC-LLM (frontier)
- Windows Foundry Local and Windows ML (frontier)
- LiteRT-LM and MediaPipe LLM Inference migration (frontier)
- ONNX Runtime GenAI (frontier)
- ExecuTorch (frontier)
- Local hardware sizing and quant selection (frontier)
- Runtime-choice matrix for Linux + RTX 5080 16GB eGPU (frontier)
Thunderbolt eGPU on Linux for local LLM inference ● 25
PCIe tunneling over Thunderbolt 4 and USB4
Linux thunderbolt driver: host_reset, CLx and bolt authorization ●
- DMAR fault triage (frontier)
- Firmware CM (ICM) / Titan Ridge limitations (frontier)
- Intel VT-d untrusted-device domain policy (frontier)
- Resizable BAR over Thunderbolt (frontier)
- Thunderbolt NVM and retimer firmware updates (fwupd) (frontier)
- USB4 router/adapter/path model (frontier)
- USB4 v2 asymmetric links and asym_threshold (frontier)
- XDomain Thunderbolt networking and thunderbolt_dma_test (frontier)
- eGPU multi-GPU LLM topology: Thunderbolt vs OCuLink (frontier)
- initramfs Thunderbolt boot-device authorization (frontier)
- pciehp hotplug and Thunderbolt root-port removal (frontier)
PCI hotplug resource assignment: hpmmiosize, realloc and BAR placement ●
- ACPI _CRS host-bridge windows vs pci=nocrs/use_crs (frontier)
- AER/DPC firmware-first vs native ownership (_OSC) on Thunderbolt root ports (frontier)
- Barlow Ridge JHL9580/JHL9586 host-reset timeouts (frontier)
- Intel IOMMU untrusted-device policy for external PCI (frontier)
- Movable BARs / ReBAR-aware resource fitting (Miroshnichenko 2020, Järvinen 2026) (frontier)
- NVIDIA NVreg_EnableResizableBar and open-driver ReBAR requirements (frontier)
- PCI bridge D3cold/runtime-PM and pci_bridge_d3_possible() exceptions (frontier)
- PCIe Link Control 2 auto-speed-disable and link retrain drops on TB eGPUs (frontier)
- Thunderbolt software vs firmware connection manager (ICM) and NVM implications (frontier)
- pciehp surprise-removal and re-add semantics for USB4 tunnels (frontier)
Diagnosing a GPU that has fallen off the bus: config space, MMIO chip ID and AER ●
- NVIDIA FSP boot chain on Blackwell (kfspWaitForResponse) vs GSP (frontier)
- PCI bridge config-vs-memory TLP forwarding and COMMAND/window semantics (frontier)
- Stable-kernel regression bisection for eGPU (backport tracking) (frontier)
- UEFI/BIOS PCIe pre-boot enumeration & Pre-Boot ACL tunnel ownership (frontier)
- USB4 asymmetric link / lane symmetry (asym_threshold) (frontier)
- Xid 154 recovery-action semantics and nvidia-smi --gpu-reset limits (frontier)
- nvidia-persistenced interaction with runtime PM on eGPUs (frontier)
- pciehp hot-remove safety in GPU drivers (nvidia vs amdgpu) (frontier)
NVIDIA open kernel module on a Thunderbolt eGPU: Xid 79, driver blocking and power management ●
- CUDA minor-version compatibility & forward-compat (PTX JIT, cuda-compat) (frontier)
- GSP firmware boot diagnostics (GSP-FMC, NVreg_EnableGpuFirmwareLogs, Xid 119/120) (frontier)
- NVIDIA driver branch lifecycle (NFB/PB/LTSB, EOL dates) (frontier)
- Ollama GPU discovery & bundled CUDA backends (cuda_v12/cuda_v13, NVML) (frontier)
- PyTorch CUDA wheel matrix & vendored runtime (cu126/cu128/cu130) (frontier)
- Ubuntu Secure Boot MOK / DKMS signing vs prebuilt linux-modules-nvidia (frontier)
- llama.cpp CUDA build matrix for sm_120 (CMAKE_CUDA_ARCHITECTURES, MXFP4) (frontier)
- nvidia-persistenced & device-node lifecycle headless (nvidia-modprobe, CDI) (frontier)
- vLLM consumer-Blackwell sm_120 kernels (NVFP4, FlashInfer, bitsandbytes gaps) (frontier)
Loading an eGPU driver after bolt with systemd ●
- AMD amdgpu eGPU hot-unplug (drm hotunplug) as contrast to NVIDIA (frontier)
- NVIDIA Container Toolkit CDI regeneration on GPU hot-attach (frontier)
- bolt enrollment policies (auto/manual/iommu) and preboot ACL for present-at-boot devices (frontier)
- initramfs-tools framebuffer hook and NVIDIA-in-initrd trimming (FRAMEBUFFER=n, MODULES=dep) (frontier)
- kmod precedence rules: install vs softdep vs blacklist vs module_blacklist= (frontier)
- pciehp surprise-removal semantics and DPC/AER on Thunderbolt tunnels (frontier)
- systemd device units: SYSTEMD_WANTS, BindsTo and DefaultDeviceTimeoutSec (frontier)
Ollama CUDA detection and GPU verification
ASUS NUC BIOS Thunderbolt options and the iSetupCfg CLI ●
- ASUS NPSS and Edge Suite (frontier)
- BIOS candidates: Above-4G, ReBAR, VT-d for eGPU (frontier)
- NUC BIOS update and recovery risk model (frontier)
- Thunderbolt security level in BIOS vs Linux authorization (frontier)
- iSetupCfg export-and-diff workflow (frontier)
- modern standby S0ix vs S3 and eGPU sleep (frontier)
PCIe power management and error handling for a Thunderbolt eGPU: ASPM, D3cold, runtime PM, AER and DPC ●
- AER native vs firmware-first (_OSC) ownership (frontier)
- DPC containment and pciehp interaction (frontier)
- NVIDIA RTD3 udev rules on an eGPU (frontier)
- NVreg_PreserveVideoMemoryAllocations and suspend (frontier)
- PCIe ASPM L1 substates and CLKREQ (frontier)
- Xid 79 triage from AER precursors (frontier)
- dev_is_removable() and ACPI ExternalFacingPort (frontier)
- pci_bridge_d3_possible() and port runtime PM (frontier)
- s2idle vs deep suspend with an eGPU (frontier)
Blackwell sm_120 local-LLM inference stack on Linux: llama.cpp, Ollama, PyTorch and vLLM over a Thunderbolt eGPU ● 1
- MoE expert CPU offload traffic over a Thunderbolt tunnel (frontier)
- Ollama cuda_v12/cuda_v13 backend selection and NVML dependency (frontier)
- PyTorch cu126/cu128/cu130 wheel matrix and driver floors (frontier)
- llama.cpp CMAKE_CUDA_ARCHITECTURES for sm_120 and MXFP4/NVFP4 kernels (frontier)
- vLLM consumer-Blackwell kernels (NVFP4, FlashInfer, bitsandbytes gaps) (frontier)
16 GB VRAM residency budgeting
- Chunked Prefill Memory Bounds (frontier)
- Context Sizing Budgets on 16GB VRAM (frontier)
- FP8 and INT4 KV Cache Quantization (frontier)
- GGUF k-quants (frontier)
- GQA KV Cache Memory Mechanics (frontier)
- NVFP4 on Blackwell sm_120 (frontier)
- PagedAttention and Memory Fragmentation (frontier)
- Sliding Window Attention (frontier)
- Weight Quantization Footprints (frontier)
- 16 GB VRAM residency budgeting (weights + KV cache) (frontier)
NVIDIA GSP and FSP firmware boot diagnostics on Blackwell under the open kernel modules ●
- FSP boot chain (kfspWaitForResponse) and GSP-FMC bootstrap (frontier)
- KMD/firmware blob version mismatch (frontier)
- NVreg_EnableGpuFirmwareLogs and reading GSP logs (frontier)
- RmInitAdapter failure ladder (frontier)
- Xid 119/120 GSP RPC timeout and error semantics (frontier)
- nouveau/nova GSP support as contrast (frontier)
Thunderbolt boot-device authorization and NVIDIA CDI for an eGPU on Linux ●
- /dev/nvidia* node lifecycle on hotplug (frontier)
- CDI spec staleness and regeneration (frontier)
- Docker --gpus vs CDI (frontier)
- Thunderbolt BootACL and preboot ACL (frontier)
- bolt IOMMU DMA-protection policy (frontier)
- dracut Thunderbolt module (frontier)
- initramfs-tools hook authoring for Thunderbolt (frontier)
- nvidia-cdi-refresh systemd units (frontier)
- nvidia-modprobe and nvidia_uvm on headless hosts (frontier)
- podman rootless CDI for NVIDIA (frontier)
GPU hot-unplug and surprise-removal safety for a Thunderbolt eGPU on Linux ●
- DPC containment vs surprise removal (frontier)
- DRM hot-unplug contract in amdgpu and xe (frontier)
- PCI core disconnected flag and all-ones MMIO (frontier)
- amdgpu removable-GPU runtime-PM policy (frontier)
- nvidia-persistenced and open file descriptors blocking removal (frontier)
- nvidia-smi drain for planned detach (frontier)
- nvidia_remove usage-count hang (frontier)
- pciehp surprise link-down handling (frontier)
Thunderbolt firmware updates and kernel-regression hygiene for a Linux eGPU ●
- GRUB saved default and apt-mark hold kernel pinning (frontier)
- LVFS coverage for eGPU enclosures and Barlow Ridge (frontier)
- Thunderbolt NVM sysfs nvm_version and nvm_authenticate (frontier)
- Ubuntu GA vs HWE kernel tracks (frontier)
- fwupd retimer offline-mode flow (frontier)
- git bisect on a kernel-only observable (frontier)
- journalctl cross-boot diff for regression triage (frontier)
- kernel taint and DKMS as regression disqualifiers (frontier)
- [email protected] and regzbot commands (frontier)
- stable backport tracking (stable-queue, stable-rc) (frontier)
Hybrid graphics on Linux: Intel iGPU plus NVIDIA eGPU for headless compute ●
- CUDA_VISIBLE_DEVICES by UUID with a late-arriving eGPU (frontier)
- PRIME render offload vs pure CUDA (frontier)
- gnome-shell VRAM footprint on a secondary NVIDIA GPU (frontier)
- mutter preferred-primary-GPU udev tag (frontier)
- nvidia-drm modeset and fbdev on a compute-only GPU (frontier)
- sharing 16 GB VRAM across multiple compute servers (frontier)
- vgaarb and boot_vga with a late-arriving eGPU (frontier)
- xe vs i915 force_probe binding checks (frontier)
Power, PSU and thermals for a Thunderbolt eGPU ●
- 12V-2x6 connector seating and sense pins (frontier)
- Core X V2 ATX PSU sizing (frontier)
- RTX 5080 360 W TGP power budget (frontier)
- Thunderbolt bus power and PD back-power (frontier)
- Xid 54 vs Xid 79 power-vs-bus fault discrimination (frontier)
- clocks throttle reasons decoding (frontier)
- eGPU soak-test runbook with abort criteria (frontier)
- nvidia-smi power-limit persistence via systemd (frontier)
- power-limit tuning for LLM inference (frontier)
Thunderbolt 5, Barlow Ridge and OCuLink eGPU topologies on Linux ●
- Barlow Ridge host-reset timeout and BAR window failures (frontier)
- MoE CPU-expert offload PCIe traffic (frontier)
- OCuLink M.2 adapter boot order and ATX PSU sequencing (frontier)
- TB5 enclosure on a TB4 host negotiation (frontier)
- USB4 v2 asymmetric links and asym_threshold (frontier)
- eGPU topology buying guide by model size (frontier)
- multi-GPU layer split vs tensor parallel over eGPU links (frontier)
PCIe link training, speed and width on a Thunderbolt eGPU ●
- AER correctable-counter baselining (frontier)
- MPS and MRRS tuning on hotplug trees (frontier)
- PCIe equalization phases and LnkSta2 fields (frontier)
- Thunderbolt tunnel bandwidth vs enclosure controller ceiling (frontier)
- Thunderbolt/USB4 cable certification and rx/tx speed sysfs (frontier)
- kernel pcie_bandwidth_available message and tunnel-port exclusion (frontier)
- safe link retrain procedure (frontier)
Measuring a Thunderbolt eGPU: bandwidth, latency and inference benchmarks ●
- CUDA bandwidthTest pinned vs pageable (frontier)
- Ollama verbose eval rates and residency (frontier)
- PCIe TLP overhead and max payload size on tunnels (frontier)
- Thunderbolt host-to-device and device-to-host duplex behaviour (frontier)
- eGPU results template and regression bisection (frontier)
- link-bound vs VRAM-bound workload classification (frontier)
- llama-bench prompt-processing vs token-generation (frontier)
- model load time cold vs warm page cache (frontier)
- nvbandwidth testcases and copy-engine vs SM (frontier)
- steady-state thermal and clock pinning (frontier)
Suspend, resume and sleep states with a Thunderbolt NVIDIA eGPU on Linux ●
- Blackwell Xid 120 suspend regressions (frontier)
- NUC modern standby and S0ix mapping (frontier)
- NVIDIA procfs suspend handshake (frontier)
- NVreg_EnableS0ixPowerManagement (frontier)
- PreserveVideoMemoryAllocations disk sizing (frontier)
- Thunderbolt tunnel fate across suspend (frontier)
- bolt re-authorization after resume (frontier)
- disabling suspend via masking, logind and GNOME (frontier)
- gnome-shell deadlock in nv_procfs_write_suspend (frontier)
- post-resume eGPU validation (frontier)
- s2idle vs S3 mem_sleep detection (frontier)
- suspend test abort and recovery (frontier)
- systemd sleep pre/post hooks (frontier)
- wake sources: WoL, RTC, USB (frontier)
Health monitoring, alerting and safe automated recovery for a Thunderbolt eGPU ●
- AER sysfs counters and rate alerting (frontier)
- BAR0 chip-ID liveness probe (frontier)
- DCGM vs NVML vs nvidia-smi on GeForce (frontier)
- NVIDIA Xid recovery-action taxonomy (frontier)
- PCI bridge COMMAND Mem/BusMaster diagnosis (frontier)
- auto-recovery rate limit, backoff and lockout state machine (frontier)
- break-glass manual recovery runbook (frontier)
- node_exporter textfile collector for hardware health (frontier)
- persistent journal kernel-evidence retention (frontier)
- systemd OnFailure oneshot watchdog pattern (frontier)
Idle power and energy accounting for an always-on Thunderbolt eGPU ●
- ATX supply light-load efficiency for an eGPU (frontier)
- DCGM exporter and textfile power metrics (frontier)
- Idle-power regression alerting after a driver change (frontier)
- Ollama keep-alive versus cold-start energy (frontier)
- Power-limit and clock-locking trade-offs (frontier)
- RAPL and powercap host energy counters (frontier)
- Runtime D3 (NVreg_DynamicPowerManagement) trade-offs (frontier)
- Wall-power metering and smart-plug accuracy (frontier)
- kWh, tariff and time-of-use cost arithmetic (frontier)
- nvidia-persistenced and persistence mode (frontier)
Unattended remote recovery and out-of-band access for a Thunderbolt eGPU host ●
- AC-loss power restore and ErP interaction (frontier)
- ATX supply remote switching and standby rail (frontier)
- Break-glass kill-switch file (frontier)
- Enclosure-only power cut is a GPU hot-unplug (frontier)
- Headless boot Thunderbolt auto-enrollment (frontier)
- Heartbeat dead-man escalation with lockout (frontier)
- Intel AMT and vPro presence check (frontier)
- Jump host as out-of-band controller (frontier)
- PCI sysfs remove and rescan recovery (frontier)
- Power-cycle ordering: services, host, enclosure (frontier)
- RTC scheduled wake from off (frontier)
- Recovery-chain drill with the owner present (frontier)
- Serial console and IP KVM for a headless NUC (frontier)
- Smart-plug power-on state and local protocols (frontier)
- Thunderbolt deauthorize and authorize rung (frontier)
- Wake-on-LAN firmware and ethtool layers (frontier)
Reproducible eGPU bring-up and configuration drift detection ●
- Ansible check and diff role for an eGPU (frontier)
- Checksum manifest with mode and owner (frontier)
- DKMS rebuild drift after a kernel upgrade (frontier)
- Excluding secrets from a config repository (frontier)
- GRUB command-line drop-in drift (frontier)
- Guard-first versus driver-first restore order (frontier)
- Idempotent installer with dry-run (frontier)
- Read-only drift verifier (frontier)
- Snapshot rollback with Timeshift, Btrfs or LVM (frontier)
- Staged-tree restore testing (frontier)
- apt-mark hold pinning (frontier)
- bolt re-enrollment after reinstall (frontier)
- dpkg conffile prompt handling (frontier)
- etckeeper as an /etc change journal (frontier)
Local LLM model load path over a Thunderbolt eGPU ●
- Cold-start budget: file size over link rate (frontier)
- Keep-warm versus reload decision (frontier)
- LM Studio JIT loading, TTL and auto-evict (frontier)
- Ollama keep-alive, preload and eviction (frontier)
- Page-cache prewarm with vmtouch and fincore (frontier)
- drop_caches for an honest cold test (frontier)
- llama-server idle sleep and router mode (frontier)
- llama.cpp load modes: mmap, mlock and direct I/O (frontier)
- mmap hides load cost: measuring time to first token (frontier)
- vLLM load formats: Run:ai streamer, InstantTensor, prefetch (frontier)
Apple Mac x NVIDIA eGPU (TinyGPU, CUDA userspace, Thunderbolt, legacy drivers) 9
TinyGPU DriverKit runtime for NVIDIA and AMD GPUs on macOS 2
Blackwell FLR defect and the deacix/tinygpu fork 1
Thunderbolt tunnel PERST# and sleep/wake recovery on macOS
tinygrad hcq1/hcq2/REMOTE refactor and macOS client wiring 1
Hardware-tested restore of the tinygrad macOS client on master
Thunderbolt and USB4 PCIe tunneling on Macs for an eGPU 2
ASM2464 USB4 docks and open firmware 1
Chestnut dock USB4-mode firmware
Mac TB4/TB5 eGPU host-to-device bandwidth benchmark 1
Negotiated MPS/MRRS on Thunderbolt eGPU bridges
CUDA userspace on macOS: tinygrad NV, NVRTC/nvcc bridge, GSP bring-up, macuda 2
NAK compiler route (tinymesa) for NVIDIA on Mac 1
NAK HMMA/IMMA tensor cores in tinygrad
GSP firmware 570 vs 575+ for Blackwell under userspace drivers 1
RTX 5060 Ti (GB206) USB4 GSP init failure
NVIDIA macOS driver history: Web Drivers, CUDA 10.2, Kepler removal
Intel Mac NVIDIA eGPU workarounds: purge-wrangler, Kryptonite, Boot Camp error 12 1
OpenCore Legacy Patcher Kepler root patching
Apple Silicon barriers to PCIe GPUs: DART, BAR memory types, no DriverKit GPU family 2
Linux VM PCI passthrough of an eGPU on macOS (QEMU/HVF + PCIDriverKit) 2
PEGPU passthrough runtime
T8110 DART SPTM panic on large-VRAM Blackwell cards
AMD eGPU on Apple Silicon (tinygrad AM driver, mac_amdgpu) 1
mac_linuxgpu: upstream Linux amdgpu in a macOS DriverKit extension
Mac NVIDIA eGPU hardware compatibility matrix: docks, enclosures, PSU, GPU generations
Working examples and benchmarks of NVIDIA eGPUs on Macs 1
CUDA prefill plus Metal decode disaggregation on one Mac 1
Apple M5 Neural Accelerators vs eGPU prefill
Using a remote NVIDIA GPU from a Mac: llama.cpp RPC, exo, served endpoints, CUDA forwarding 1
llama.cpp RPC tensor-parallel and RDMA internals 1
Thunderbolt IP throughput between a Mac and a Linux NVIDIA host
Running LLM models locally on a Mac ● 21
Mac local LLMs: Agent clients, context and compaction ● 32
mcp-compressor wrapper proxy in front of a local-model agent ●
MCP tool-definition token cost in OpenCode ●
Multi-root skill discovery and duplicated skill directories ●
OpenCode compaction config for local providers ●
Responses API client-executed tool_search support in local servers ●
Rewriting llama-server overflow errors to Claude Code's recognised wording ●
Router session keying when subagents reuse metadata.user_id ●
Task-success versus tool count and prompt size for small local models ●
Agent skill-listing injection cost ●
Claude Code compaction floor of 100K versus small local windows ●
Claude Code context-window mismatch against local servers ●
Claude Code effort levels forwarded to local Anthropic-compatible servers ●
Claude Code gateway hint headers for local routers ●
Claude Code helper-model request to custom base URL ●
Claude Code reactive compaction error-wording recognition ●
claude-code-router Anthropic-to-OpenAI translation over a local gateway ●
Claude Code skill listing budget formula ●
CLAUDE_CODE_SUBAGENT_MODEL routing of subagents to a small local model ●
Claude Code system-prompt and tool-schema slimming for local models ●
Claude Code unknown-model context window handling ●
Client-side compaction thresholds for hybrid-model local servers ●
Codex auto-compaction body_after_prefix scope ●
Codex model catalog JSON (model_catalog_json) for local model slugs ●
Codex model-visible tool exposure rules (spec_plan.rs namespace_tools capability ●
Codex namespace and hosted tool types skipped by local servers ●
Codex provider capabilities struct and where namespace serialization is gated ●
Codex tool_search deferred MCP tools and the supports_search_tool catalog flag ●
Flattening proxies for Codex namespace tools (codex-ollama-proxy and similar) ●
Hook additional-context injection into the first message ●
llama.cpp normalisation of Claude Code billing header cch ●
Local LLM server as a coding-agent backend on Mac ●
Local router policy keyed on x-claude-code-request-class ●
Mac local LLMs: ANE and Core ML LLMs ● 17
maderix reverse-engineered ANE hardware profile ●
Orion ANE constraint catalog and direct-ANE programming ●
Orion direct-ANE runtime via private ANEClient ●
Speculative decoding verify batches to amortize ANE dispatch ●
Speculative decoding with ANE-resident drafter ●
SqueezeBits Yetter disaggregated ANE-prefill GPU-decode engine ●
ANE dispatch and IOSurface round-trip overhead in small decode graphs ●
ANE numerics hazards in FP16 ●
ANE-prefill plus GPU decode hybrid inference ●
ANE SRAM 32 MB cliff and graph-depth utilization ●
ANE SRAM cliff for 1x1 conv and decode-shaped tensors ●
ANE weight-read bandwidth by chip ●
ANEMLL ANE LLM conversion pipeline ●
Core ML and Apple Neural Engine for LLMs ●
Core ML stateful KV-cache compile constraints ●
Core ML to MLX KV cache hand-off cost and layout ●
CoreML-LLM john-rocky ANE LLM runtime ●
Mac local LLMs: Apple Foundation Models and Core AI ● 8
mlx-swift-lm and MLXFoundationModels adapter ●
MLXGuidedGeneration and XGrammar constrained decoding on Apple Silicon ●
Server-side prefix cache behavior under rolling-window transcripts ●
Apple foundation-models-utilities ChatCompletionsLanguageModel ●
Core AI framework ●
Dynamic Profiles historyTransform ●
fm serve and the fm CLI OpenAI-compatible endpoint ●
Mac local LLMs: Benchmarking and comparisons ● 13
MLX discussion 2990 five-node M3 Ultra RDMA benchmark thread ●
MLX vs llama.cpp decode and prefill by model size and context ●
Prefill-parity gating of prefill tokens-per-second in cross-runtime reports ●
Prompt-token counting parity across runtimes ●
Time-to-first-token measurement artifacts ●
apple-silicon-llm-bench fairness rules and interleaved-arm protocol ●
Benchmark methodology pitfalls for local LLM runtimes ●
Dense vs MoE MLX vs llama.cpp decode on Apple silicon ●
Dependent-chain versus queue-batched MLX kernel benchmarking ●
exo vs mlx.launch tensor-parallel throughput controlled comparison ●
guruswami-ai mlx-benchmarks cluster dataset ●
llama.cpp build-number drift in published Mac benchmarks ●
llm-benchpacks workload-level agent benchmarks ●
Mac local LLMs: Chat templates, reasoning and tool calling ● 31
Ollama Anthropic adapter tool_use block fidelity ●
Ollama count_tokens 404 stall with Claude Code ●
Ollama native tool-call parser extraction for Qwen function XML ●
Ollama Qwen3.8 reasoning-effort instructions injected into the system turn ●
Ollama structured outputs on thinking models ●
oMLX per-model chat template kwargs and cache-key construction ●
OpenAI gpt-oss compatibility test script for verifying server implementations ●
Parse-then-render byte round-trip tests for reasoning turns ●
Qwen 3.8 chat-template fixes and reasoning-level mapping ●
Qwen chat template whitespace normalisation of tool-call and think blocks ●
Qwen3.6 preserve_thinking chat-template flag and prompt-cache reuse ●
Reasoning-block trailing newline parser bug causing agent loops ●
Reasoning field naming across servers ●
Reasoning-parser versus tool-parser interaction ●
Token-level generation-versus-render drift measurement harness ●
Tool-call parser and chat-template mismatch ●
Tool-call repair proxies and self-healing parsers ●
Tool-calling benchmarks for local models ●
vLLM parser engine grammar (vllm/parser) and structural-tag strict tool calling ●
vLLM XML tool_call emitted inside think block loses tool calls ●
XGrammar structural tags for Gemma 4 and Harmony tool calls ●
Anthropic-compatible local endpoints and mid-conversation role system messages ●
Codex Responses API compatibility on local servers ●
Gemma 4 thought stripping in agentic turns ●
gpt-oss Harmony reasoning replay across tool calls ●
LiteLLM Anthropic-to-Chat-Completions translation bugs for Claude Code ●
llama.cpp autoparser analyze_reasoning, analyze_content and analyze_tools diff p ●
llama.cpp autoparser workaround lambdas in chat-diff-analyzer.cpp ●
llama.cpp reasoning-budget sampler and lazy grammar trigger gating ●
llama.cpp reasoning-preserve vs Qwen preserve_thinking template key aliasing ●
llama.cpp Responses SSE event ordering and reasoning items ●
Mac local LLMs: Clusters, RDMA, exo and ds4 ● 54
macOS 26.2 stops self-assigning IPv4 on Thunderbolt RDMA interfaces ●
macOS 27 libthunderboltrdma rework ●
macOS network service order and Thunderbolt Bridge auto-creation on upgrade ●
mlx distributed error propagation via event poisoning (PR 3523, 3742) ●
MLX expert parallelism all_to_all PR 3158 ●
mlx.launch jaccl backend flags and hostfile coordinator handling ●
mlx.launch remote teardown bug (tmp.None pid file) ●
MLX_METAL_FAST_SYNCH and JACCL GPU fence_wait deadlock ●
Model-free 8-10 KiB all_sum loop on 2 and 4 JACCL nodes ●
Per-collective all_sum latency in decode over JACCL RDMA ●
Per-token collective count times per-call latency model ●
Routed-expert ownership split under ds4 streaming TP ●
Silent-corruption testing for distributed collectives with rank-distinct data ●
Small-message JACCL all_sum latency microbenchmark protocol ●
Static link-local IPv4 per Thunderbolt port for JACCL meshes ●
Tensor-parallel all-reduce count per transformer layer in MLX shard_linear ●
Tensor vs pipeline vs expert parallelism for MoE in mlx-lm ●
Thunderbolt Bridge bridge0 and STP fixes for RDMA mesh setup ●
Two exo models sharing one Mac GPU under fast synch ●
UC queue pair one-direction drop warm-up check ●
Uninterruptible Us+ rank processes in the Thunderbolt RDMA driver ●
Apple libthunderboltrdma tbt_post_recv SIGSEGV ●
Apple UC send into a queue pair with no posted receive kills that direction ●
Application-level no-progress watchdog and group re-formation for JACCL clusters ●
Distributed inference across Macs ●
ds4 layer pipeline parallelism over TCP with activation quantization ●
ds4 manual cache safe-bytes cap (7/8 of recommended working set minus context) ●
ds4 own verbs layer versus JACCL ●
ds4 streaming expert cache sizing under TP ●
ds4 TP big-gate bulk exchange for prefill over RDMA ●
ds4 TP gate chunking and 16-gate receive lookahead window ●
ds4 TP speculative-verify block window over RDMA (tag 0xB5) ●
ds4 TP with --ssd-streaming on Metal for GLM and V4.1 ●
ds4 two-Mac tensor parallelism over Thunderbolt RDMA setup ●
exo cluster software ●
exo DeepSeek V4 expert sharding (ShardedMoEV4) as EP substitute ●
exo MLX_METAL_FAST_SYNCH only for RDMA instances (exo PR 2377) ●
exo orphaned runner holds RDMA queue pairs (RTR errno 16) ●
exo pinned MLX fork ●
exo PR 2348 plan loop no longer waits for generation task acknowledgement ●
exo prefill/decode disaggregation ●
exo ring-abort detection by stderr diagnostic (PR 2367) ●
exo set_rdma_network_config.sh network setup script ●
exo stuck-runner 90-second no-progress watchdog (PR 2370) ●
ibv_devinfo hang as an RDMA health probe ●
JACCL coordinator-optional connection setup (mlx PR 3899) ●
JACCL mesh versus ring topology selection and per-pair device counts ●
JACCL peer-liveness side channel and progress timeout PR 4530 ●
JACCL protection domain exhaustion on repeated mx.distributed.init ●
JACCL RDMA completion status checking and silent corruption ●
JACCL ring all_reduce wire partitioning (n_wires, directions, threads) ●
JACCL silent hang on peer loss ●
JACCL TCPAllGather side channel as peer-liveness channel ●
llama.cpp RPC -sm tensor PR 26610 ●
Mac local LLMs: GPU stability and kernel panics ● 17
macOS 27 IOGPUFamily changes and whether the panic is fixed ●
macOS Tahoe GPU command-buffer hangs ●
Metal GPU hangs with multiple concurrent engines in one process ●
Metal GPU watchdog 5 s timeout in distributed MLX generation ●
MetalGuard user-space GPU-crash mitigations ●
MLX command-buffer error capture and event poisoning in 0.32.0 ●
MLX command-buffer error propagation PR 3742 ●
MLX_METAL_FAST_SYNCH effect on event synchronization hangs ●
MLX Metal queue contention between two processes on one GPU ●
MLX PR 4552 Metal fence deadlock fix in 0.32.3 (MLX_METAL_FAST_SYNCH) ●
oMLX engine serialization A/B (OMLX_SERIALIZE_ENGINE_GPU) results ●
oMLX multi-engine GPU serialization and cross-engine Metal queue contention ●
Two llama.cpp or llama-swap models loaded concurrently on one GPU: stability ●
WindowServer GPU contention and display-sleep mitigation ●
GPU firmware lockup reports gpuEvent ips ●
IOGPUFamily driver bug and userspace panic mitigations such as MetalGuard ●
M5 Max watchdogd 90 s kernel panic under sustained GPU load ●
Mac local LLMs: KV cache sizing and quantization ● 19
Metal flash attention K.type==V.type constraint ●
Mixed-precision KV-cache quantization per-layer sensitivity ●
Pre-M5 vs M5 Apple GPU decode behavior for compressed KV ●
QJL residual correction needed or harmful ●
Sparse V attention-gated dequant ●
TriAxialKV per-role mixed-precision KV quantization for agentic prefills ●
TurboQuant and rotation-based KV quantization on Metal ●
TurboQuant KV cache compression (Hadamard, Lloyd-Max, QJL) ●
Cross-layer attention (CLA) KV sharing ●
Gemma 4 attention_k_eq_v global-layer key-as-value sharing ●
Gemma 4 shared KV cache layers YOCO ●
Gemma 4 sliding-window layer exclusion from KV quantization ●
KV cache and long context on Mac ●
KV cache quantization (4-bit and 8-bit) memory pricing and NaN failures in MTPLX ●
KV-cache quantization degrading tool-call accuracy ●
KV-cache quantization effect on tool-call flips (int8 vs int4) ●
KV cache quantization tradeoffs on Apple GPUs ●
LCKV and YOCO cross-layer KV sharing variants ●
llama.cpp attention rotation Hadamard for quantized KV cache ●
Mac local LLMs: llama.cpp internals ● 31
Metal residency sets and llama.cpp Metal internals ●
mmproj versioning and mismatch errors for multimodal GGUFs ●
mtmd mergeable bitmaps and temporal frame merging for Qwen-VL video ●
mtmd_tokenize_from_parts per-segment tokenization for marked input ●
Jinja templates failing on llama.cpp engine but passing in Python ●
llama.cpp causal_attn flag scheduler re-reserve cost per image (PR 28751) ●
llama.cpp chat.cpp per-template regex rewrites versus Jinja input marking ●
llama.cpp context checkpoint 64-token minimum tuning ●
llama.cpp context checkpoints and SWA hybrid prompt re-processing ●
llama.cpp --fit auto memory fitting ●
llama.cpp gemma4uv projector type support and first supporting build ●
llama.cpp jinja capability probes chat_template_caps ●
llama.cpp Jinja input marking is_input special-token injection defence ●
llama.cpp Jinja runtime (minja replacement) tojson and filter semantics ●
llama.cpp message_spans chat-template user-boundary detection for checkpoints ●
llama.cpp Metal backend on Mac ●
llama.cpp --mtmd-batch-max-tokens tuning against n_ubatch for non-causal project ●
llama.cpp mtmd batching of consecutive image chunks into one non-causal decode ●
llama.cpp mtmd lazy bitmaps for frame-by-frame video ●
llama.cpp mtmd video and webp input via ffmpeg subprocess (MTMD_VIDEO, PR 27520) ●
llama.cpp PR 25592 exact-position hybrid checkpoint restore ●
llama.cpp reasoning-preserve flag and template support detection ●
llama.cpp seq_pos_min hybrid memory fix PR 24797 ●
llama.cpp slot state trimming when the template will drop reasoning ●
llama-fit-params tool and freezing fitted flags into a launch script ●
llama_n_ctx_seq semantics with and without unified KV ●
llama-server /props n_ctx as the per-slot window to advertise to clients ●
llama-server router child bind address versus router --host ●
llama-server router subprocess build option (subprocess is not enabled on this b ●
llama-server slot and unified-KV configuration ●
llama-server --video-fps, --video-timestamp-interval and --video-ffmpeg-dir flag ●
Mac local LLMs: Memory and wired limits ● 32
macOS memory compressor thrashing from GPU-visible buffers ●
macOS memorystatus and jetsam behavior on non-iOS Macs under memory pressure ●
macOS no_paging_space_action Out of Application Memory dialog ●
macOS swap and compressed memory write behavior under memory pressure ●
macOS unified buffer cache policy and wired memory interaction ●
macOS vm pressure level thresholds kVMPressureWarning and kVMPressureCritical ●
macOS vm.user_wire_limit and RLIMIT_MEMLOCK for mlock ●
macOS wired memory limit and GPU kernel panics ●
MADV_DONTNEED on file-backed mmap semantics on macOS ●
Metal mmap span mapping and residency-set wiring for partial offload ●
Metal newBufferWithBytesNoCopy file-cache-backed weights refault ●
mincore MINCORE_PAGED_OUT probe for compressor residency of Metal buffers ●
mincore residency probing of mmap'd model weights on macOS ●
MLX buffer pool reuse window and cache sizing (mlx issue 3886) ●
mlx-optiq residency ceiling near 73 percent of RAM ●
mmap mlock and no-mmap on Apple silicon ●
MTLResidencySet requestResidency postponement under cross-app pressure ●
SSD endurance and wear under local LLM inference ●
task_info TASK_VM_INFO resident_size versus phys_footprint accounting ●
Throughput cliff versus vm_stat decompressions on 24 GB M4 ●
XNU vm_per_task_user_wire_limit and global wire sysctl defaults on Apple silicon ●
Allocation path behind MTLResourceStorageModeShared buffers (IOGPU vs IOSurface) ●
Apple Silicon SSD SMART telemetry and Percentage Used interpretation ●
Apple silicon unified memory and LLM sizing ●
Cost of a mincore sweep per GB on Apple silicon ●
GGUF tensor reordering script with gguf-py plus hash verification ●
GPU-written no-copy buffer footprint charging ●
IOKit-mapped Metal buffer accounting in phys_footprint ●
JangPress RSS accounting after expert deactivation on macOS ●
llama.cpp lazy-mode lazy tensor reading of oversized embedding tables ●
llama.cpp PR 25309 sparse mmap tensor range coalescing ●
llama-server --load-mode dio and lazy-mode on Apple silicon ●
Mac local LLMs: MLX kernels, numerics and internals ● 26
MLX 0.31.2 thread-safety PRs and delivered levels ●
mlx 0.32.0 JACCL patch inventory ●
MLX allocator memory limit GC limit and buffer cache ●
MLX batched decode scheduler crashes ●
MLX gemv_wide bf16 fp16 few-row matmul kernel PR 3888 ●
MLX get_qmv_batch_limit per-generation tuning table ●
MLX_METAL_GPU_ARCH architecture override as NAX kill switch ●
MLX mixed fp16 and bf16 type promotion in arithmetic ●
MLX NAX kernel gating and quantized matmul ●
MLX new_thread_unsafe_stream API and Swift concurrency use ●
MLX Python scalar weak typing with half-precision arrays ●
MLX qmm_splitk small-M split-K quantized matmul ●
MLX qmv_wide kernel PR 3764 and affine gen-15+ gating ●
MLX thread-local streams and cross-thread lazy array evaluation crashes ●
MLX ThreadLocalStream per-thread resolution and cross-thread synchronize no-op ●
NAX-aware qmm_splitk for small-M quantized matmul on M5 ●
Prism ML ternary Hadamard-rotated weights kernel on Metal ●
FP16 attention partial-sum overflow in split attention kernels on M1 and M2 ●
Gemma 4 vision tower standardize overflow and mmproj dtype on Metal ●
Gemma4ClippableLinear input/output clamp scalars in the mmproj ●
JACCL GID selection regression and RTR errno 22 (mlx 3467) ●
JACCL MeshImpl all_reduce race fix mlx 3451 ●
JACCL ring all_gather direction-1 slice bug (mlx PR 4443) ●
JACCL RTR sgid_index hard-coded to 1 ●
M5 GPU TF32 numerics and batched attention divergence ●
M5 NAX tensor-unit kernels in MLX servers ●
Mac local LLMs: MoE streaming and offload ● 20
MoE expert offload to SSD on macOS ●
MoE expert SSD streaming and page-cache residency ●
MoE-PHDS post-hoc declared sparsity fine-tune ●
rustane warm-page-cache pread fanout (ncdrone/rustane) ●
Sequential read throughput of expert-sized reads by Apple SSD configuration ●
SSD bandwidth growth per Apple chip generation and 397B projection ●
SSD expert streaming and cluster sharding for MoE on Mac ●
Zipfian hot-row cache tier for n-gram tables (DRAM over NVMe) ●
Aggregate SSD bandwidth when each cluster node streams experts ●
Apple NVMe small random read latency under F_NOCACHE at queue depth 16 ●
Apple SSD speed dependence on NAND capacity and package count ●
ds4 antirez SSD streaming runtime ●
ds4 decode-time Engram read latency on Apple SSD (48 random reads per token) ●
Engram and n-gram embedding tables read from disk per token ●
Engram row prefetch overlapped with preceding transformer blocks in Mac runtimes ●
Expert-cache policy and on-disk layout for MoE streaming ●
Expert-count reduction at inference top-k override ●
Flash-MoE paper flash_moe.pdf 90+ experiment log ●
Flash-MoE SSD-streamed MoE expert runtime ●
JangPress cold-expert eviction for MoE larger than RAM ●
Mac local LLMs: Ollama internals ● 17
ollama create from safetensors with MLX quantization ●
Ollama default 262144 context and num_ctx memory cost on Mac ●
Ollama DFlash block-diffusion draft model in mlxrunner ●
Ollama engine vs llama engine loader split and mmap support ●
Ollama GGUF import renderer detection (qwen3.8 renderer selection) ●
Ollama KV rotation port (OLLAMA_KV_ROTATE) ●
Ollama launcher flag set passed to llama-server ●
Ollama llama/compat patch layer for llama.cpp ●
Ollama MLX backend and NVFP4 on Apple silicon ●
Ollama mlxrunner speculative depth controller (committed tokens per second) ●
Ollama Modelfile RENDERER and PARSER directives and the renderer/parser registri ●
Ollama multimodal projector offload disable policy ●
Ollama qwen3_5 MTP loader and SelfDraft path ●
Ollama runner no-mmap default on Metal and use_mmap option ●
Ollama usesOllamaRenderedChat versus native llama-server Jinja chat path ●
Ollama VRAM-tiered default num_ctx and v1 num_ctx dropping ●
llama.cpp bundled revision inside Ollama releases ●
Mac local LLMs: oMLX, Rapid-MLX and related internals ● 23
MTPLX memory guard and request pricing on 8-128 GB Macs ●
MTPLX MTP self-drafting Mac server ●
oMLX and Rapid-MLX runtimes ●
oMLX boundary snapshot store serialization and async cache-store worker locking ●
oMLX fatal teardown watchdog and wired memory stranding (issues 2334 and 2184) ●
oMLX GDN sidecar and rotating-window snapshot size ●
oMLX /health liveness versus scheduler wedge ●
oMLX hybrid GDN boundary snapshot capture regression ●
oMLX issue 2330: scheduler never dispatches after two identical cached prefills ●
oMLX issue 2624: engine stops dispatching for 6 hours with every thread idle ●
oMLX memory guard tiers and prefill ceiling on 16-24 GB Macs ●
oMLX Metal cache clears wait for the owning stream (PRs 2412 and 2413) ●
oMLX OMLX_DISABLE_PRESSURE_RECLAIM and request_pressure_reclaim scheduler path ●
oMLX per-model SSD cache isolation quotas and stale-block eviction ●
oMLX ProcessMemoryEnforcer pressure levels and adjust_store_cache_cap ●
oMLX remaining ad-hoc mx.clear_cache sites needing stream analysis ●
oMLX shared MLX executor thread versus per-engine streams ●
oMLX store-cache admission gate and 60 s admission stall error ●
oMLX trailing partial block and restore-latency limits ●
oMLX VLM versus text engine selection and per-model settings ●
Osaurus inference scheduler, model leases and single-residency handoff ●
osaurus vmlx-swift-lm runtime and vmlxctl ●
Hybrid and recurrent model checkpoint handling in oMLX ●
Mac local LLMs: Prompt cache and persistent KV ● 28
MTPLX SSD session cache and SessionBank warm-prefix reuse ●
oMLX paged SSD cache auto limit policy ●
Prefix-cache-safe handling of non-leading system turns ●
Prefix-stability regression testing of chat templates ●
Prompt-cache invalidation by agent clients ●
Prompt cache survival across model unload swap and server restart ●
Rapid-MLX server and kv-disk-checkpoint-interval ●
Rapid-MLX shutdown-time disk save ●
Reasoning-token cache invalidation across turns ●
SSD write budgets and wear for KV session stores ●
stillwarm llama-server KV persistence wrapper ●
vLLM-Metal hybrid KV cache manager and prefix caching ●
Agent-owned KV cache export import artifacts ●
CachyLlama llama.cpp fork with persistent KV ●
Chat-template and tool-declaration determinism as a cache-hit prerequisite ●
Chat-template patching for cache stability ●
Context shift and cache-overflow policy for recurrent models ●
Disk and SSD-tiered KV cache servers ●
ds4 disk KV cache and SHA1 byte-prefix keying ●
Exact tool-call replay for byte-stable agent prefixes ●
Hybrid and sliding-window attention KV cache rewinding ●
KV checkpoint eviction scoring by tokens per byte with hit decay ●
llama.cpp host-memory prompt cache cache-ram cache-idle-slots on unified memory ●
llama.cpp host prompt cache interaction with id_slot pinning ●
llama.cpp prompt-cache eviction when cache-ram limit is hit ●
llama-server host-memory prompt cache and idle sleep unload ●
LLAMA_SERVER_SLOTS_DEBUG mismatch logging workflow ●
llama-swap lifecycle hooks and wrapper-based KV save restore ●
Mac local LLMs: Quantization evaluation ● 26
Metal flash-attention kernel partitioning differences across M-series chips ●
MoE expert coverage in imatrix calibration ●
Non-canonical tokenization robustness of instruction-tuned models ●
per-expert coverage and per-expert KLD attribution for MoE quants ●
Qwen 3.6 27B GGUF quality benchmark per-quant KL (localbench, 87 quants) ●
Qwen3.5-27B dense Unsloth KLD table for dense versus MoE elasticity ●
Reference self-flip floor from cache_prompt and batch-size nondeterminism ●
router top-k agreement under quantization as a diagnostic ●
size-matched KLD reporting for local quants ●
Tail-risk quant metrics 99.9% KLD max KLD top-1 agreement ●
BFCL and tool-calling evals for quantized local models ●
Branch-and-follow flip analysis harness for Mac GGUF and MLX quants ●
Calibration-set contamination and held-out evaluation corpora ●
Confidence-conditioned top-1 flip rate for literal-copy tokens ●
Cross-engine reference logits precision and tokenizer parity ●
Effect of the 16-nat logit clamp in the .kld encoder on tail KLD ●
Effective bits-per-weight and size confounds in MLX N-bit quant names ●
First Divergent Token metric rollouts on GGUF and MLX quants ●
Gemma 4 31B GGUF quants ranked by KL divergence ●
Generation-drift metrics beyond prefill KLD ●
Head-to-head top-40 versus full-vocabulary KLD on one model and text ●
Importance-matrix presence as a second axis in equal-size KLD comparisons ●
KLD-based quant evaluation methodology ●
llama.cpp .kld reference file binary layout and external reader ●
localbench top-40 union KL estimator versus .kld full-vocab KLD ●
Log-log size-to-KLD elasticity of K-quants across model families ●
Mac local LLMs: Quantization formats and methods ● 22
Mixed-precision quantization for MoE experts 4-bit attention 8-bit ●
MoE router and shared-expert precision protection in quant recipes ●
oMLX custom quantization loader dispatcher (maybe_load_custom_quantization) ●
ParoQuant pairwise-rotation quantization for MLX ●
Quantization formats for Apple silicon (GGUF vs MLX) ●
Silent wrong-output loading of Hadamard-rotated F16 GGUF in stock llama.cpp ●
Ternary GGUF packings PTQ1_0 and PQ2_0 in the Prism llama.cpp fork ●
TQ4_1S Hadamard-rotated weight quantization in llama.cpp fork ●
TurboQuant Hadamard-rotation codebook weight quantization ●
UD-IQ4_NL_XL and legacy Q4_NL Q5_1 types on Metal kernels ●
Unsloth Dynamic GGUF methodology ●
Upstreaming Prism ternary types 142/143 into llama.cpp and Ollama ●
Vector LUT and mixed 2/4-bit GPTQ quantization for ANE ●
Data-driven mixed-precision MLX quants (oQ, OptiQ, JANG) ●
Gemma 3/4 float16 activation overflow handling across runtimes ●
Gemma 4 float16 conversion guard for M1/M2 MLX ●
Gemma 4 mobile-mixture QAT with TQ2_0 2-bit layers (UD-Q2_K_XL for E2B/E4B) ●
Gemma 4 QAT GGUF conversion: F16 versus BF16 scales in llama.cpp Q4_0 ●
GGUF re-upload versioning and stale cache hygiene ●
llama-quantize --tensor-type-file recipes for MoE shared experts ●
llama-quantize --tensor-type-file role-aware policies (attention/FFN/boundary) ●
M1/M2 software-emulated bfloat16 and FP16 conversion ●
Mac local LLMs: Runtime selection and frontends ● 13
MLX and mlx-lm on Apple silicon ●
Model selection by Mac RAM tier ●
Ollama 0.40 MLX-by-default rollout and opt-out ●
Ollama on macOS ●
Unsloth Desktop Studio macOS app running GGUF and MLX ●
Unsloth server-side tools versus agent passthrough ●
Unsloth Studio as an Anthropic-compatible endpoint for Claude Code ●
Hybrid Mamba-2 and MoE model support across Mac runtimes ●
llama.cpp default port change to 9931 ●
Llama-macOS menu-bar app ●
llama serve command (router-mode daemon front end) ●
LM Studio MLX engine ●
LM Studio on Mac ●
Mac local LLMs: Serving ops and multi-model ● 18
macOS TCC Files and Folders consent for boot-time daemons ●
Multi-model serving and memory budgeting in vllm-mlx and oMLX registries ●
Multi-model serving on a large Mac with llama-swap ●
Per-model memory measurement with footprint and IOAccelerator ●
router --models-max swap ordering (unload before load) peak memory ●
Service accounts and API-key hardening for LAN-exposed local LLM servers ●
Supervisor-side liveness probes for llama-server (completion probe plus SIGKILL) ●
Continuous batching and aggregate throughput on MoE ●
Continuous batching and concurrent-request serving on Apple silicon ●
Continuous batching on MLX ●
fdesetup authrestart and FileVault pre-boot unlock for headless Macs ●
Headless Apple silicon Mac virtual display and the interactivity watchdog ●
launchd ExitTimeOut and graceful stop discipline for large MLX models ●
launchd service setup for local LLM servers ●
llama.cpp --sleep-idle-seconds router sleeping state keeps its models-max slot ●
llama-server readiness and health semantics after fatal Metal init OOM ●
llama-server router mode child instance exposure and auth ●
Long-running MLX server OOM recovery and process recycling ●
Mac local LLMs: Speculative decoding and MTP ● 37
Metal attention multi-row verify cliff at 6-15 query rows ●
MLX 0.32.2 tensor-unit expert-sorted quantized matmul row-limit bug on M5 ●
mlx gemv_wide bf16 small-M kernel in mlx 0.32.1 ●
MLX quantized_matmul small-M verify kernels ●
MoE GatherQMM small-M verify cost ●
MoESD analysis of MoE speculative decoding batch-size regimes ●
MTP head norm-convention and double-shifted trunk detection ●
MTPLX compiled verifier (GraphBank) windows and eager fallback by context length ●
MTPLX flash-decoding verify attention kernel (sdpa_nax_flash) ●
MTPLX Forge and MTP-preserving MLX conversion ●
MTPLX Sustained versus Turbo presets and which use compiled verify ●
N-gram and prompt-lookup self-speculation for coding agents ●
Speculative decoding and MTP on Apple silicon ●
Speculative decoding with structured-output grammar at reasoning boundaries ●
Target-side deferred commit for recurrent state (SGLang DFlash worker) ●
Ternary Bonsai 2 27B on MTPLX with grafted Qwen3.8 draft head ●
Training an MTP adapter for a model with no native head ●
Tree attention verification on hybrid recurrent targets ●
Acceptance drift of a base MTP head on a distilled trunk ●
Adaptive block-size scheduling for DFlash at inference ●
Depth policy that measures draft and verify cost per depth ●
DFlash and DDTree speculative decoding drafters ●
DFlash block-diffusion drafters on hybrid targets in llama.cpp (PR 22105) ●
DFlash image-input position gap in llama.cpp draft context ●
Draft length tuning (spec-draft-n-max) for block-diffusion drafters ●
Expert-deduplicating gather kernels for verify windows on Metal ●
Expert overlap between draft tokens in MoE speculative verification ●
Gemma-4 assistant drafters on MLX and llama.cpp ●
Grafting a base model's MTP head onto a fine-tuned trunk (MiMo-V2.6 distill) ●
Grammar-aware draft filtering for ngram and draft-model drafters ●
Hardware-calibrated verification budget for batch-wide tree speculation ●
Hybrid GatedDeltaNet state rollback and checkpoint prefix caching ●
llama.cpp EAGLE-3 and DSpark speculator drafters ●
llama.cpp ngram-mod and ngram-map-k4v drafter internals ●
llama.cpp ngram-mod speculative stuck loop (issue 23268, PR 25819) ●
llama.cpp --spec-default and low-acceptance streak reset (PRs 22223 and 22168) ●
llama.cpp speculative checkpointing for hybrid models (PRs 19493 and 22227) ●
Mac local LLMs: Speed, bandwidth and prefill ● 18
macOS 27 TensorOps FP8 FP4 MX scale planes ●
Metal 4 tensor API and M5 Neural Accelerator prefill in llama.cpp ●
Metal prefill cost of Q8_0 shared experts beside Q4_K routed experts ●
MoE active-parameter decode on unified memory ●
Prompt processing versus decode on Apple GPUs and Neural Accelerators ●
Q4_K_M dequantization cost vs MLX affine g64 on dense decode ●
Q4_K_M vs Q4_K_S decode on MoE (Q6_K ffn_down_exps share) ●
Q6_K Metal mat-vec cost inside Q4_K_M files ●
Resident-model standing power overhead on unified memory (about 21 W) ●
Sustained-load thermal throttling ANE versus GPU decode ●
Thermal, power and battery behavior during local inference ●
UltraFusion die-to-die latency and irregular MoE access ●
Wall-power meter calibration of SoC-rail energy estimates ●
Apple silicon memory bandwidth and decode speed by chip ●
Energy per token measurement on Apple Silicon ●
IOReport Energy Model channels versus powermetrics samplers ●
Isolated Metal microbenchmark of Q6_K vs Q4_K mat-vec at matched bytes ●
llama.cpp MoE tensor-API port ●
LLM Fine-Tuning & PEFT ●
- Fine-tune vs RAG vs prompt decision framework (frontier)
- Full fine-tuning vs PEFT (memory, plasticity-stability) (frontier)
- LoRA mechanics (rank/alpha/target_modules/init) (frontier)
- LoRA family (QLoRA, DoRA, rsLoRA, LoRA+) (frontier)
- Non-LoRA PEFT (adapters, (IA)^3, prefix/P-tuning/prompt-tuning) (frontier)
- HuggingFace PEFT + TRL workflow (frontier)
- Multi-LoRA serving: merge vs swap + adapter merging (frontier)
- Catastrophic forgetting and mitigations (frontier)
- SFT data preparation and chat templating (frontier)
- Fine-tuning tooling stack (Unsloth/Axolotl/Llama-Factory/torchtune) (frontier)
- Evaluating a fine-tune (task + capability-regression) (frontier)
Transformer Architecture Internals & Variants ●
- Self-attention and multi-head attention (QKV, causal mask, KV cache) (frontier)
- Positional encoding (RoPE, ALiBi, NoPE, absolute) (frontier)
- Attention-efficiency variants (MQA, GQA, MLA) (frontier)
- FlashAttention (IO-aware exact attention, v1/v2/v3) (frontier)
- Normalization and placement (RMSNorm, pre/post-norm, DeepNorm) (frontier)
- Gated FFN (SwiGLU/GeGLU) (frontier)
- Long-context extension (PI, NTK, YaRN, context-parallel) (frontier)
- Mixture-of-Experts (top-k routing, load balancing, DeepSeek-V3, expert parallelism) (frontier)
- Alternative and hybrid architectures (Mamba/Mamba-2, linear attention, RWKV, Jamba) (frontier)
- Tokenization (BPE, byte-level BPE, SentencePiece, tiktoken) (frontier)
GPU & Accelerator Kernels for LLMs ●
- GPU execution model (SMs, warps, SIMT, occupancy) (frontier)
- Memory hierarchy (registers/SRAM/L2/HBM) and IO-bound attention (frontier)
- Arithmetic intensity and the roofline (prefill compute-bound vs decode memory-bound) (frontier)
- Precision and tensor cores (BF16/TF32, FP8, MX/MXFP4, NVFP4, INT8) (frontier)
- CUDA basics (coalescing, shared memory, bank conflicts, CUDA graphs) (frontier)
- Triton kernels (tile/block programming, autotune) (frontier)
- Kernel fusion (frontier)
- FlashAttention kernel implementation (tiling, online softmax, FA-3 warp specialization/WGMMA/TMA) (frontier)
- Paged and quantized KV-cache kernels (frontier)
- NCCL collective primitives (ring vs tree) (frontier)
- Profiling and MFU (Nsight Systems/Compute, PyTorch profiler) (frontier)
- Hardware landscape (Hopper to Blackwell, AMD MI300X/MI350X, Google TPU) (frontier)
- Compilers (torch.compile/TorchInductor, TensorRT-LLM, XLA, Mojo) (frontier)
RLHF & RL Training Infrastructure ●
- Actor-rollout-learner architecture (three engines + experience buffer; 4-model PPO vs critic-free GRPO topology) (frontier)
- Co-located/hybrid vs disaggregated GPU placement (veRL 3D-HybridEngine, OpenRLHF Ray placement groups, single- vs multi-controller) (frontier)
- The generation/rollout bottleneck (60-90%+ of step time, <40% actor GPU util, long-tail stragglers, vLLM/SGLang in-the-loop) (frontier)
- Train->infer weight resync (NCCL packed broadcast / CUDA-IPC / delta-sync; resharding across mismatched layouts via sharding managers; vLLM sleep-wake) (frontier)
- Async / off-policy RL systems (AReaL fully-async streaming + staleness <=8 steps; one-step-off; APRIL partial-rollout recycling) (frontier)
- The RL framework landscape (veRL, OpenRLHF, NeMo-Aligner/NeMo-RL, TRL, slime, AReaL, ROLL, SkyRL, TorchForge) (frontier)
- Reward-model serving + verifier/code-execution sandboxes in the loop (frontier)
- Scaling the trainer (FSDP/Megatron) alongside the rollout engine (smaller-TP + high-DP) (frontier)
- RL GPU under-utilization bubble + OPPO intra/inter-step overlap + Ray-vs-Slurm orchestration (frontier)
- RL-systems failure modes (train/inference logprob mismatch -> TIS, vLLM temperature logprob gotcha, MoE Keep-Routing gap, weight-sync desync, reward over-optimization) (frontier)
Prompt caching ●
- Model Selection and Pricing (frontier)
- Fine-Tuning and Local Inference (frontier)
- Embeddings (frontier)
- Diffusion & Generative Models (frontier)
LLM training, evaluation and red-teaming
Local LLM Inference on Consumer Hardware (RTX 5080 eGPU, Linux, Remote Access) 11
Linux eGPU for LLM Inference (Thunderbolt 3/4/5, USB4, OCuLink)
- Hybrid MoE prefill vs link bandwidth benchmark (x16 vs OCuLink vs TB5 vs TB4) (frontier)
- llama.cpp op-offload threshold and ubatch tuning on slow links (frontier)
- NVIDIA open-module eGPU patches (TB4/TB5 detection, hot-unplug) (frontier)
- BAR1 / Resizable BAR sizing over Thunderbolt tunnels (frontier)
- TB5 controller (Barlow Ridge) vs ASM2464PD USB4 bridge behavior (frontier)
- OCuLink signal integrity and AER / replay counters (frontier)
- Blackwell power-cap curves: prefill vs decode per watt (frontier)
- Tensor-parallel over TB/OCuLink links (frontier)
RTX 5080 / Blackwell Consumer CUDA Stack on Linux (sm_120)
- Xid 79 / GSP 'fallen off the bus' on GB20x (frontier)
- NVFP4 vs MXFP4 vs Marlin W4A16 on 16 GB sm_120 (frontier)
- FlashInfer on sm_120 (JIT toolchain, backend gaps) (frontier)
- CUDA family targets 120a vs 120f in llama.cpp/vLLM builds (frontier)
- PyTorch cu128 drop and driver pinning strategy (frontier)
- NVIDIA apt pinning packages vs Ubuntu -open metapackages, Secure Boot MOK (frontier)
- FlashAttention-4 sm_120 readiness (frontier)
- TensorRT-LLM / SGLang consumer-Blackwell backend matrix (frontier)
Remote access to a local LLM server
- Server bind and API surfaces (Ollama, LM Studio llmster, llama-server, vLLM) (frontier)
- Remote chat clients (Open WebUI, LibreChat, Jan, AnythingLLM, Msty) (frontier)
- LM Studio LM Link (frontier)
- Coding-agent clients (Continue, Cline, Aider, OpenAI SDK base_url) (frontier)
- Tailscale and tailscale serve (frontier)
- SSH local port forwarding (frontier)
- Ollama Host-header check and proxy 403 (frontier)
- Docker bypassing ufw (frontier)
- Reverse proxy auth (Caddy, nginx) (frontier)
- Cloudflare Tunnel with Access service tokens (frontier)
Exposed local-LLM server security
- Internet scans of exposed Ollama hosts (frontier)
- LLMjacking campaigns (frontier)
- Ollama CVEs (Probllama, DNS rebinding, GGUF DoS) (frontier)
- llama.cpp rpc-server CVEs (frontier)
- vLLM pickle and api-key coverage gaps (frontier)
- llama-server slots prompt leak (frontier)
Hybrid CPU+GPU MoE expert offload
- llama.cpp --n-cpu-moe and --cpu-moe (frontier)
- Tensor overrides (-ot / --override-tensor) (frontier)
- llama.cpp auto-fit (-fit) (frontier)
- GPU-offloaded prompt processing and GGML_OP_OFFLOAD_MIN_BATCH (frontier)
- RAM-bandwidth-bound MoE decode (frontier)
- eGPU link effect on MoE prefill (frontier)
- ik_llama.cpp hybrid inference (frontier)
- KTransformers CPU/GPU MoE engine (frontier)
- Ollama expert-offload gap (frontier)
- LM Studio expert-offload toggle regression (frontier)
Model picks for the 16GB VRAM + 64GB RAM tier (2026)
- Qwen3.8-27B dense VL (frontier)
- Qwen3.6-35B-A3B MoE (frontier)
- Qwen3-Coder-Next 80B-A3B (frontier)
- gpt-oss-120b and gpt-oss-20b MXFP4 (frontier)
- Gemma 4 26B-A4B and 12B (frontier)
- GLM-4.7-Flash (frontier)
- Mistral Small 4 119B-A6B (frontier)
- Hybrid-attention KV budgets (frontier)
- Unsloth Dynamic GGUF quant choice (frontier)
- KV-cache quantization at 16GB (frontier)
Local LLM Troubleshooting Playbook and Recommended Settings (Ollama, LM Studio, llama-server) 1
- Ollama VRAM-tier default context and silent chat truncation (frontier)
- llama-server --fit auto context shrink and ctx-per-slot (frontier)
- LM Studio context overflow policy (frontier)
Ollama CPU/GPU split diagnosis and env-var tuning ●
- GPU-not-detected CPU fallback (nvidia_uvm after suspend, container toolkit) (frontier)
- Cold-load latency and keep_alive / TTL residency (frontier)
- Chat template and EOS failures (--jinja, Go TEMPLATE) (frontier)
- gpt-oss Harmony format serving (frontier)
- Reasoning-format parsing and think-tag leakage (frontier)
- Local tool calling and grammar-constrained JSON (frontier)
- Per-family vendor sampling defaults and GGUF sampling metadata (frontier)
- Repetition loops vs repeat_penalty vs presence_penalty (frontier)
- 16GB-card baseline config for Ollama, LM Studio, llama-server (frontier)
OpenClaw and personal-agent gateways on local models
- OpenClaw history and renames (Warelay, Clawdbot, Moltbot, foundation) (frontier)
- OpenClaw Gateway architecture (daemon, channels, skills, memory, heartbeat, sandbox) (frontier)
- OpenClaw local model providers (Ollama native API, LM Studio Responses API, OpenAI-compatible servers) (frontier)
- Local model capability floors (64k context, tool-calling reliability, injection resistance) (frontier)
- OpenClaw security record (exposed gateways, CVE-2026-25253, ClawHavoc supply chain) (frontier)
- OpenClaw hardening baseline (loopback bind, token auth, DM pairing, tool deny, sandbox) (frontier)
- Personal-agent gateway alternatives (Open WebUI, LibreChat, Hermes Agent, goose, n8n, nanobot, IronClaw) (frontier)
Open WebUI deployment and hardening as the remote chat front end
- Pinned-tag docker compose bound to loopback behind tailscale serve (frontier)
- Host backend reachability via host-gateway and docker0 binding (frontier)
- First-admin, signup and pending-role behavior (frontier)
- ConfigVar persistent-config trap on environment variables (frontier)
- Per-model presets, global defaults and the num_ctx override (frontier)
- Native tool-calling default and its context cost (frontier)
- RAG embedding offload and web-loader SSRF controls (frontier)
- Tools and Functions as root-equivalent code execution (frontier)
- Community function supply-chain risk (frontier)
- Advisory history and vendor stance on plugin attack chains (frontier)
- License branding clause with the 50-user exception (frontier)
- Image size and RAM footprint by tag (frontier)
- Upgrade, one-way migrations and cold backup (frontier)
- Tailscale identity-header SSO caveats (frontier)
- Open WebUI versus LibreChat, AnythingLLM and Jan (frontier)
DDR5 and Host Tuning for CPU-Side LLM Inference and MoE Offload
- DDR5 theoretical vs measured bandwidth (channels x MT/s x 8, IFOP/FCLK/UCLK limits) (frontier)
- Measuring memory bandwidth on Linux (mbw, STREAM, likwid-bench, Intel MLC, dmidecode configured speed) (frontier)
- XMP/EXPO profiles and JEDEC vs platform-supported speeds (Intel and AMD 1DPC/2DPC matrices) (frontier)
- 4-DIMM downclocking and 2x32 vs 2x48 vs 4x32 capacity trade-offs (frontier)
- Decode tokens/s estimate: effective bandwidth over active bytes per token (frontier)
- llama.cpp thread count, SMT, Intel E-cores, CCD and taskset/cpu-mask affinity (frontier)
- Hugepages, THP, mlock/--load-mode and NUMA settings for CPU inference (frontier)
- CPU governor and amd-pstate EPP for memory-bound LLM decode (frontier)
- Prefill compute-bound vs decode memory-bound and expert placement (frontier)
- Upgrade paths: faster kits, 96/128GB, Strix Halo, quad/8-channel HEDT and Xeon 600 (frontier)
FP8 / NVFP4 / MXFP4 Safetensors Serving on vLLM and SGLang (single 16GB sm_120 card)
- b12x SM120/SM121 kernel backend (CuTe DSL) for NVFP4 and MXFP4 (frontier)
- Speculative decoding with MTP or DFlash heads on 16GB consumer cards (frontier)
- NVFP4 KV cache on consumer Blackwell (sm_120 FMHA gap) (frontier)
- NVFP4 quantization recipes: RTN vs GPTQ vs AWQ+AutoRound, protected layers, KL divergence (frontier)
- vLLM sleep mode for sharing one GPU with Ollama or LM Studio (frontier)
- vLLM MoE expert cache and CPU offload (moe-expert-cache-size) (frontier)
- FP8 KV cache calibration and skip-layers for hybrid attention models (frontier)
- vLLM startup time: compile cache, KV profiling, weight-cache Fast Start (frontier)
- SGLang consumer Blackwell (sm_120) FP4 and FP8 GEMM backends (frontier)
- Ollama versus raw llama.cpp throughput gap on RTX 5090 (frontier)
- KL-divergence benchmarking of GGUF versus vLLM quantized checkpoints (frontier)
LLM engineering and local deployment 5
LLM document extraction and text distillation pipeline
`document-distiller` reads ONE doc and inventories its atomic units. This skill is the **corpus** counterpart with a different output contract: read EVERYTHING under a root (a site or a repo),…
- layout-aware document parsing (frontier)
- heuristic boilerplate removal (frontier)
- text canonicalization for deduplication (frontier)
- semantic vs lexical deduplication (frontier)
- hybrid retrieval fusion and reranking (frontier)
- structured output constraints (frontier)
- extraction evaluation frameworks (frontier)
Code generation model benchmarks and quantization impact
- HumanEval MBPP CodeXGLUE benchmarks (frontier)
- quantization impact on code accuracy (frontier)
- code model hallucination rates (frontier)
- code model selection and deployment economics (frontier)
Continuous Learning System ● 1
Conceptual Family Exploration ●
Given subject, find useful/relevant/novel/interesting concepts in its conceptual family **currently missing** from skill library and concept tree, fill worthwhile ones to saturation via `/dr`,…
- Conceptual Family Mapping (frontier)
- Concept Viability Scoring (CVS) (frontier)
- Saturation Loop Control (frontier)
- Gap-Driven /dr Orchestration (frontier)
- Coverage Inventory and Gap Detection (frontier)
- Instinct-Based Learning (frontier)
- Confidence Score Tracking (frontier)
- Hook-Driven Session Observation (frontier)
- Skill Evolution from Instincts (frontier)
Structured Output Constraints and LLM Hallucination Mitigation ●
MCP Server Development ● 2
MCP Server Builder Patterns ●
- FastMCP Python Patterns (frontier)
- TypeScript SDK Patterns (frontier)
- Tool Design Checklist (frontier)
- MCP Deployment Patterns (frontier)
- Production Hardening (frontier)
Plaud MCP Integration ●
- Plaud Tool Quick Reference (frontier)
- Session State and Elicitation (frontier)
- Cost Safety Controls (frontier)
- Skills as Resources (frontier)
- JSON-RPC 2.0 Architecture (frontier)
- MCP OAuth 2.1 Security (frontier)
- Sampling and Elicitation (frontier)
- MCP Deployment (frontier)
Retrieval & RAG 3
Retrieval-augmented generation: iterative retrieval, re-ranking, score fusion, and agentic RAG.
Iterative Retrieval ●
- Context Refinement Patterns (frontier)
- Subagent Context Problems (frontier)
- Progressive Information Fetching (frontier)
Cross-Encoder Re-ranking vs Bi-Encoders for Terminal Validation in RAG and Deduplication ●
Hybrid Score Fusion (Reciprocal Rank Fusion - RRF) ●
Business & Enterprise 5
TAM work, financial-services accounts, ecommerce, careers, and ventures.
Financial-Services Accounts 2
Bank account intelligence, big-bank IT landscapes, and buyer-side vendor risk.
Big-Bank IT and Infrastructure Landscape
- Core banking systems and system-of-record vs system-of-engagement (frontier)
- Bank data-center to cloud journey and cloud-architecture constraints (frontier)
- Latency-sensitive trading infra and payments rails (RTGS, FedNow, ISO 20022, 24x7) (frontier)
- Batch windows and mainframe modernization (the Rs, strangler-fig, encapsulation) (frontier)
- Change governance, change-freeze, segregation of duties and the regulated SDLC (frontier)
- Resiliency and DR (RTO/RPO, active-active, recovery testing) and SRE at banks (frontier)
- Bank data-platform and integration landscape, build-vs-buy and in-house engineering (frontier)
Enterprise Vendor Management, Procurement & Third-Party / Operational-Resilience Risk (Buyer-Side)
- TPRM Lifecycle & Vendor Risk Tiering (frontier)
- Standardized Security Assessments & Evidence (SIG, CAIQ, SOC 2, ISO 27036, trust centers) (frontier)
- Enterprise Procurement & Strategic Sourcing (Kraljic, RFx, S2P suites) (frontier)
- Negotiation Levers, SLAs/OLAs, Vendor Scorecards & Buyer-Run QBRs (frontier)
- Vendor Consolidation & Rationalization (frontier)
- Contract-Instrument Stack (MSA, SOW, Order Form, DPA, SCCs, precedence) (frontier)
- Operational-Resilience & Systemic Third-Party Regulation (DORA, OCC/FFIEC, UK PRA/FCA CTP, Basel) (frontier)
- Concentration, Fourth-Party, Exit Plans & Substitutability (frontier)
- The Vendor-Selling-In Playbook (parallel gates, regulatory flow-down, evidence package) (frontier)
TAM Operating Reference 6
TAM Expertise ●
- Account Health Assessment (frontier)
- EBR and QBR Preparation (frontier)
- Churn Risk Analysis (frontier)
- Customer Success Frameworks (frontier)
- MEDDPICC and NRR Metrics (frontier)
Case Tracker
- Case Lifecycle Management (frontier)
- Tracker Record Schema (frontier)
- Severity System (frontier)
- LLM Analysis Pipeline (frontier)
Case MCP Server Guide
- MDB Case Assistant Startup (frontier)
- Tool Selection for Case Workflows (frontier)
- Case MCP Troubleshooting (frontier)
Semantic Monitoring, Reporting & Customer Dashboards for TAM (value-chain synthesis) ● 6
Semantic Layer and Headless BI ●
- Metric store / metrics layer (frontier)
- Semantic model primitives (entities, dimensions, measures, semantic graph) (frontier)
- Metric types and composability (MetricFlow) (frontier)
- Dynamic SQL generation (frontier)
- Metric governance (code, Git, CI, access control) (frontier)
- Universal vs native semantic layer (frontier)
- dbt Semantic Layer / MetricFlow (frontier)
- Cube (headless BI) (frontier)
- AtScale (virtual OLAP cube) (frontier)
- Looker LookML (frontier)
- Open Semantic Interchange (OSI) (frontier)
- Query APIs and BI connectivity (SQL/JDBC/GraphQL/MDX/DAX) (frontier)
- Pre-aggregation and caching (frontier)
- Grounding AI text-to-SQL agents in governed metrics (frontier)
Data Observability ●
- Five Pillars (freshness, volume, schema, distribution, lineage) (frontier)
- Data Downtime (frontier)
- Data SLAs/SLOs/SLIs (frontier)
- Data Incident Management (frontier)
- Anomaly Detection on Pipelines (frontier)
- Data Lineage and OpenLineage/Marquez (frontier)
- Observability Tooling Landscape (frontier)
- Shift-Left and Data Contracts (frontier)
- Observability vs Quality vs Testing vs Monitoring (frontier)
Data Visualization ● 1
Customer-Facing and Embedded Analytics Dashboards ●
- Embedded / White-Label / Headless / GenBI Taxonomy (frontier)
- Embedded-Analytics Platform Landscape 2026 (frontier)
- Decision-First Curation and Value Framing (frontier)
- Multi-Tenant Isolation (signed JWT/guest tokens + server-side RLS) (frontier)
- Sub-Second-at-Concurrency Performance (frontier)
- Freshness vs Latency and Last-Updated Indicators (frontier)
- Metric Consistency via Governed Semantic Layer (frontier)
- Customer-Facing UX Patterns and WCAG-AA Chart Accessibility (frontier)
- Customer Value / Health Dashboard Angle (frontier)
- Build-vs-Buy on TCO (frontier)
- Perceptual foundation (Cleveland & McGill) (frontier)
- Tufte's principles (frontier)
- Knaflic / Few storytelling and dashboard design (frontier)
- Gestalt principles for charts (frontier)
- Chart selection by intent (frontier)
- Color theory and palettes (frontier)
- WCAG accessibility for charts (frontier)
- Grammar of graphics (Wilkinson, Wickham layered) (frontier)
- Visualization tooling map (frontier)
- Dashboard design rules (frontier)
- Visualization anti-patterns (frontier)
- Visualization workflow (frontier)
Reporting and Communication ●
- BLUF (Bottom Line Up Front) (frontier)
- Minto Pyramid Principle (frontier)
- SCQA framework (frontier)
- Data storytelling (Knaflic) (frontier)
- Action titles (frontier)
- Audience adaptation (executive / technical / operational) (frontier)
- Executive summary one-pager (frontier)
- Technical report structure (IMRaD) (frontier)
- Reproducibility appendix (frontier)
- Recommendation framing with confidence levels (frontier)
- Alternatives considered (frontier)
- Notebook-as-report (Jupyter / Quarto / Observable / R Markdown) (frontier)
- Dashboards and live reports (frontier)
- Honest framing of uncertainty (frontier)
- Uncertainty taxonomy (frontier)
- Anti-patterns of analytical writing (frontier)
Value Realization and Outcome-Based Customer Success ●
- Promised vs Perceived vs Realized Value (frontier)
- Time-to-Value (TTV) (frontier)
- Outcome-based vs Activity-based CS (frontier)
- Desired Outcome = Required Outcome + Appropriate Experience (Murphy) (frontier)
- Mutual Success Plans (MAP) and Value Scorecards (frontier)
- Business Value Assessment and the Value Hypothesis (frontier)
- Customer Maturity and Journey Models (frontier)
- Outcome vs Output vs Activity Metrics (leading vs lagging) (frontier)
- Digital / Scaled / Tech-Touch CS (frontier)
- CS Platform Landscape 2026 (Gainsight/ChurnZero/Totango-Catalyst/Vitally/Planhat) (frontier)
- Incident Management (frontier)
- Account Lifecycle (frontier)
TAM account management 1
TAM commercial metrics ●
- Net Revenue Retention (NRR) (frontier)
- Gross Revenue Retention (GRR) (frontier)
- MEDDPICC qualification (frontier)
- SaaS retention/churn/expansion benchmarks 2025-2026 (frontier)
Membership Ecommerce 6
Members-Only and Wholesale Pricing
Squarespace Commerce and Payments
Membership Site Architecture
Membership Platforms Build vs Buy
High-Risk Payments and Chargeback Management
Ecommerce Sales-Tax Nexus Compliance
Job search and career operations 2
Automated job application tooling and strategy
Service-industry and bartending careers
Personal Venture — NC Organ-Donation Nonprofit & Founder Toolkit ●
- Organ Donation System & NC Law (venture-organ-donation-system) (frontier)
- Organ Donation Frontier & Advocacy (venture-organ-donation-frontier) (frontier)
- NC Nonprofit Formation & 501(c)(3) (venture-nc-nonprofit-formation) (frontier)
- Cause & Nonprofit Marketing (venture-cause-nonprofit-marketing) (frontier)
- Nonprofit Fundraising Ops (venture-nonprofit-fundraising-ops) (frontier)
- Donor & Community Engagement (venture-donor-community-engagement) (frontier)
- Canva & Founder Brand Stack (venture-canva-founder-brand-stack) (frontier)
- Marketing Strategy & Local SEO (venture-marketing-strategy-local-seo) (frontier)
- Small Business Planning (venture-small-business-planning) (frontier)
- Startup Fundraising Deck & Model (venture-startup-fundraising-deck-model) (frontier)
- NC Business Formation & Tax (venture-nc-business-formation-tax) (frontier)
- NC Entity Lifecycle (venture-nc-entity-lifecycle) (frontier)
- NC Employer & Payroll (venture-nc-employer-payroll) (frontier)
- NC Real Estate Law (venture-nc-real-estate-law) (frontier)
- Real Estate Marketing & Investing (venture-real-estate-marketing-investing) (frontier)
- Real Estate Advanced — PM, STR & Creative Finance (venture-real-estate-advanced) (frontier)
Data Analysis 41
data engineering and pipelines
- workflow orchestration (frontier)
- dbt analytics engineering (frontier)
- lakehouse architectures (frontier)
- batch vs streaming Lambda Kappa (frontier)
- data contracts (frontier)
- data quality testing (frontier)
- pipeline observability (frontier)
streaming analytics
- Kafka (frontier)
- Flink (frontier)
- Spark Structured Streaming (frontier)
- watermarking (frontier)
- exactly-once semantics (frontier)
- windowing (frontier)
- stream processing patterns (frontier)
forecasting
- ARIMA family (frontier)
- exponential smoothing ETS (frontier)
- Prophet NeuralProphet (frontier)
- ML forecasting (frontier)
- foundation models TimeGPT Chronos Moirai TimesFM (frontier)
- hierarchical reconciliation MinT (frontier)
- intermittent demand Croston SBA (frontier)
- prediction intervals conformal (frontier)
anomaly detection ●
- statistical methods z-score MAD ESD (frontier)
- CUSUM EWMA control charts (frontier)
- change-point detection PELT BOCPD (frontier)
- LOF density methods (frontier)
- Isolation Forest (frontier)
- one-class SVM elliptic envelope (frontier)
- autoencoder VAE deep methods (frontier)
- streaming detection River PySAD (frontier)
- drift vs anomaly (frontier)
feature engineering and feature stores
- numerical transforms Box-Cox Yeo-Johnson (frontier)
- categorical encoding target encoding (frontier)
- datetime cyclical features (frontier)
- automated feature engineering Featuretools AutoFeat OpenFE (frontier)
- feature stores Feast Tecton Hopsworks Databricks Vertex SageMaker (frontier)
- point-in-time correctness (frontier)
- train-serve consistency (frontier)
- online feature serving (frontier)
- feature monitoring drift freshness lineage (frontier)
Marketing Mix Modeling and Incrementality ●
- Adstock and carryover transformations (frontier)
- Saturation and Hill curves (frontier)
- Bayesian MMM and priors (frontier)
- Open-source MMM frameworks (Robyn, Meridian, PyMC-Marketing) (frontier)
- Multi-touch attribution vs MMM (frontier)
- Incrementality testing (frontier)
- Geo-lift experiments (GeoLift, TBR, CausalImpact) (frontier)
- Privacy-era post-cookie measurement (frontier)
- MMM calibration with experiments (frontier)
Product Analytics ●
- Event taxonomy & tracking plans (frontier)
- North Star metric framework (frontier)
- Funnel & conversion analysis (frontier)
- Activation & aha moment (frontier)
- Feature adoption (frontier)
- Engagement & stickiness (DAU/WAU/MAU) (frontier)
- Session & path analysis (frontier)
- Metric frameworks (AARRR vs HEART) (frontier)
- Experimentation operations (frontier)
- Analytics governance & data quality (frontier)
- Product-analytics tooling (frontier)
Reverse ETL and Operational Analytics ●
- Reverse ETL vs ETL/ELT (frontier)
- Data activation and operational analytics (frontier)
- Composable/warehouse-native vs packaged CDP (frontier)
- Identity and entity resolution (frontier)
- Audience building and syncs (frontier)
- Sync mechanics (incremental diffing, CDC, idempotency, DLQ) (frontier)
- Destination API rate limits and error handling (frontier)
- Activation observability and data quality (frontier)
- Governance, PII and consent in activation (frontier)
- Semantic/metrics layer relationship (frontier)
- Reverse ETL vendor landscape 2024-2026 (frontier)
Network and Graph Analytics ●
- Graph representations (adjacency matrix/list, directed/weighted, bipartite, ego networks) (frontier)
- Connectivity and shortest paths (connected components, BFS, Dijkstra, Bellman-Ford) (frontier)
- Centrality measures (degree, betweenness, closeness, eigenvector, PageRank) (frontier)
- Community detection (Louvain, Leiden, label propagation, modularity, resolution limit) (frontier)
- Link prediction (common neighbors, Jaccard, Adamic-Adar, preferential attachment) (frontier)
- Network motifs and bipartite projection (frontier)
- Graph embeddings (node2vec, DeepWalk) (frontier)
- Graph neural networks for analytics (GCN, GraphSAGE) (frontier)
- Graph analytics tooling (NetworkX, igraph, graph-tool, cuGraph, Neo4j GDS) (frontier)
Bayesian Data Analysis and Probabilistic Programming ●
- Bayesian workflow (Gelman/Vehtari) (frontier)
- Priors and prior predictive checks (frontier)
- MCMC (NUTS/HMC) (frontier)
- Variational inference (ADVI) (frontier)
- Hierarchical/multilevel models (partial pooling, non-centered parameterization) (frontier)
- Posterior predictive checks (frontier)
- Model comparison (LOO-CV/PSIS, WAIC) (frontier)
- Convergence diagnostics (R-hat, ESS, divergences, BFMI) (frontier)
- Probabilistic programming languages (PyMC, Stan, NumPyro, Bambi) (frontier)
- Bayesian regression and GLMs (frontier)
- ArviZ diagnostics and plotting (frontier)
Customer Lifetime Value Modeling ●
- Buy-Till-You-Die (BTYD) framework (frontier)
- Pareto/NBD model (frontier)
- BG/NBD model (frontier)
- MBG/NBD model (frontier)
- Gamma-Gamma monetary model (frontier)
- RFM as sufficient statistics (frontier)
- Discounted Expected Residual Transactions (DERT) (frontier)
- sBG shifted-beta-geometric (contractual) (frontier)
- BG/BB discrete-time non-contractual (frontier)
- Predictive vs historical CLV (frontier)
- Cohort-based CLV (frontier)
- CAC:LTV ratio (frontier)
Survival Analysis ●
- Censoring and Truncation (frontier)
- Survival and Hazard Functions (frontier)
- Kaplan-Meier and Nelson-Aalen Estimators (frontier)
- Log-Rank Test (frontier)
- Cox Proportional-Hazards Model (frontier)
- Proportional-Hazards Assumption and Diagnostics (frontier)
- Parametric and Accelerated Failure Time Models (frontier)
- Competing Risks (Cause-Specific and Fine-Gray) (frontier)
- Time-Varying Covariates (frontier)
- Discrete-Time Survival and Churn/CLV (frontier)
- Machine-Learning Survival Models (frontier)
Causal Discovery and Structure Learning ●
- Constraint-based methods (PC, FCI) (frontier)
- Score-based search (GES, GIES) (frontier)
- Functional causal models (LiNGAM, ANM, PNL) (frontier)
- Continuous-optimization methods (NOTEARS, GOLEM, DAG-GNN) (frontier)
- Permutation search (GRaSP, BOSS) (frontier)
- Markov equivalence classes and CPDAGs (frontier)
- Faithfulness and causal sufficiency assumptions (frontier)
- Latent confounders (FCI, PAGs/MAGs) (frontier)
- Time-series causal discovery (Granger, PCMCI, VAR-LiNGAM) (frontier)
- Interventional data (frontier)
- Evaluation metrics (SHD, SID) (frontier)
- Causal discovery tooling (causal-learn, gCastle, Tigramite, pcalg) (frontier)
Data Governance Catalogs and Discovery ●
- DAMA-DMBOK and DCAM governance frameworks (frontier)
- Metadata management and active metadata (frontier)
- Data discovery and search (frontier)
- Table-level and column-level data lineage (frontier)
- Business glossaries (frontier)
- Data stewardship and ownership roles (frontier)
- Data classification and tagging (frontier)
- Access governance and policy enforcement (ABAC) (frontier)
- Data products and data mesh federated computational governance (frontier)
- Data contracts (ODCS and ODPS) (frontier)
- Catalog tooling landscape (DataHub, OpenMetadata, Amundsen, Atlan, Collibra, Alation, Unity Catalog, Purview) (frontier)
Conformal Prediction and Uncertainty Quantification ●
- Marginal coverage guarantee (frontier)
- Exchangeability assumption (frontier)
- Nonconformity scores (frontier)
- Split/inductive conformal prediction (ICP) (frontier)
- Full/transductive conformal prediction (frontier)
- Conformalized quantile regression (CQR) (frontier)
- Adaptive prediction sets (APS/RAPS) (frontier)
- Mondrian/group-conditional conformal (frontier)
- Weighted conformal under covariate shift (frontier)
- Conformal for time series (EnbPI, ACI) (frontier)
- Calibration vs sharpness (frontier)
- Conformal risk control (frontier)
- Conformal vs Bayesian credible intervals and bootstrap (frontier)
- Tooling (MAPIE, crepes, TorchCP) (frontier)
Real-Time OLAP and Analytical Databases ●
- Columnar storage (frontier)
- Vectorized (SIMD) execution (frontier)
- Real-time vs batch analytics (Lambda/Kappa) (frontier)
- Streaming ingestion and upserts (Kafka/Pulsar/Kinesis) (frontier)
- Materialized views and pre-aggregation (frontier)
- ClickHouse MergeTree indexing (sparse primary index, data-skipping) (frontier)
- Star-schema-on-OLAP and denormalization (frontier)
- Storage-compute separation / shared-data / tiered storage (frontier)
- High-QPS user-facing analytics (frontier)
- OLAP engines vs cloud data warehouses (frontier)
- Embedded OLAP (DuckDB) (frontier)
Geospatial Analytics ●
- Vector vs Raster Data Models (frontier)
- Coordinate Reference Systems & Projections (frontier)
- Spatial Predicates & DE-9IM (frontier)
- Spatial Joins (frontier)
- Geometric Operations (frontier)
- Spatial Indexing (R-tree, Geohash, H3, S2) (frontier)
- Spatial Weights (frontier)
- Spatial Autocorrelation (Moran's I, LISA, Geary's C) (frontier)
- Point-Pattern Analysis (frontier)
- Interpolation & Kriging (frontier)
- Geocoding (frontier)
- Choropleth Mapping & Classification (frontier)
- Spatial Regression (GWR, Spatial Lag/Error) (frontier)
Prescriptive Analytics and Optimization ●
- Linear Programming (frontier)
- Mixed-Integer Programming (frontier)
- Convex Optimization (frontier)
- Constraint Programming (CP-SAT) (frontier)
- Stochastic and Robust Optimization (frontier)
- Multi-Objective Optimization (Pareto) (frontier)
- Decision Analysis (Decision Trees, EVPI, Utility) (frontier)
- Simulation for Decisions (DES, Monte Carlo, Queueing) (frontier)
- Decision Intelligence (frontier)
- OR Application Archetypes (Routing, Scheduling, Assignment, Inventory, Blending) (frontier)
Text Analytics and NLP for Analysts ●
- Text preprocessing, tokenization, normalization (frontier)
- Bag-of-words, TF-IDF, n-grams (frontier)
- Topic modeling (LDA, NMF, BERTopic) (frontier)
- Sentiment analysis (lexicon VADER vs transformer) (frontier)
- Named-entity recognition (frontier)
- Text classification (frontier)
- Keyword and keyphrase extraction (RAKE, YAKE, KeyBERT) (frontier)
- Embeddings and semantic clustering (word2vec, sentence-transformers) (frontier)
- Document similarity (frontier)
- LLM-assisted qualitative coding and structured extraction (frontier)
- Evaluation of NLP outputs (frontier)
Data FinOps and Cost Optimization ●
- FinOps Framework for data cloud platforms (inform/optimize/operate, Scopes) (frontier)
- Snowflake credit and virtual warehouse cost model (frontier)
- BigQuery on-demand vs Editions/slots cost model (frontier)
- Databricks DBU/Photon/serverless cost model (frontier)
- Warehouse right-sizing and auto-suspend (frontier)
- Query cost attribution and chargeback/showback (frontier)
- Partition pruning, clustering, and materialized views for cost (frontier)
- Storage tiering and Time Travel/lifecycle cost (frontier)
- Spend monitoring and cost anomaly detection (frontier)
- Data unit economics (cost per query/dashboard/pipeline/model run) (frontier)
- Cost-aware data modeling (incremental models, avoid SELECT *) (frontier)
- FinOps tooling (dbt Cost Insights/Fusion, SELECT.dev, Bluesky, native dashboards) (frontier)
Cohort and Retention Analytics ●
- Acquisition vs behavioral cohorts (frontier)
- Retention curve shapes (smile/flattening/dead-on-arrival) (frontier)
- N-day vs unbounded vs bracket vs rolling retention (frontier)
- Retention and engagement relationship (frontier)
- Growth accounting (users) (frontier)
- Growth accounting (revenue/MRR) and quick ratio (frontier)
- DAU/WAU/MAU and stickiness ratio (frontier)
- Churn rate vs retention rate asymmetry (frontier)
- Net and gross revenue retention (NRR/GRR) (frontier)
- Sean Ellis test and power-user curve (L28/L30) (frontier)
- Building cohort retention tables in SQL (frontier)
Synthetic Data Generation ●
- Why synthetic data (privacy, augmentation, testing, rebalancing) (frontier)
- Tabular synthesis methods (Gaussian copula, CTGAN, TVAE, CopulaGAN, CART/sequential) (frontier)
- Deep generative methods (GANs, VAEs, diffusion/TabDDPM) (frontier)
- Class imbalance: SMOTE/ADASYN vs generative (frontier)
- Differentially private synthesis (DP-GAN, PATE-GAN, PrivBayes, MST, SmartNoise) (frontier)
- Tools and frameworks (SDV, SDMetrics, synthcity, synthpop) (frontier)
- Fidelity vs utility vs privacy evaluation (TSTR, DCR, membership inference) (frontier)
- Text and image synthesis overview (frontier)
- Regulatory context (GDPR, ICO, NIST) (frontier)
Dimensional and Analytics Data Modeling ●
- Kimball Dimensional Modeling (frontier)
- Conformed Dimensions and Bus Matrix (frontier)
- Slowly Changing Dimensions (SCD 0-7) (frontier)
- Fact Table Types (frontier)
- Surrogate vs Natural Keys (frontier)
- Specialized Dimensions (degenerate/role-playing/junk) (frontier)
- Inmon vs Kimball vs Data Vault 2.0 (frontier)
- One Big Table vs Star Schema (frontier)
- Medallion Architecture (bronze/silver/gold) (frontier)
- dbt Modeling Layers and Materializations (frontier)
- Semantic vs Physical Modeling (frontier)
Recommender Systems and Learning-to-Rank Analytics ●
- Problem Framing (Explicit vs Implicit Feedback, Feedback Loop, Cold-Start) (frontier)
- Collaborative Filtering (User-User, Item-Item, Neighborhood) (frontier)
- Matrix Factorization (SVD, funkSVD, ALS, WRMF, BPR) (frontier)
- Content-Based and Hybrid Recommenders (frontier)
- Factorization Machines (FM, FFM, DeepFM) (frontier)
- Modern Deep Recommenders (Two-Tower, Neural CF, Sequential SASRec/BERT4Rec/GRU4Rec) (frontier)
- LLM-Augmented and Generative Recommenders (Semantic IDs) (frontier)
- Learning-to-Rank (Pointwise, Pairwise RankNet, Listwise ListNet/LambdaMART) (frontier)
- Offline Evaluation Metrics (NDCG, MAP, MRR, Recall@k, Coverage, Diversity, Serendipity) (frontier)
- Online and Off-Policy Evaluation (A/B, Interleaving, IPS, Doubly-Robust) (frontier)
- Production Concerns (Candidate Generation, Feature/Embedding Stores, Bandits, Fairness) (frontier)
Pricing and Revenue Analytics ●
- price elasticity of demand (own/cross-price) (frontier)
- price endogeneity and IV identification (frontier)
- demand-curve and discrete-choice demand (logit/nested/mixed/BLP) (frontier)
- willingness-to-pay measurement (Van Westendorp/Gabor-Granger/conjoint/MaxDiff) (frontier)
- price optimization and revenue management (yield/dynamic/markdown/laddering) (frontier)
- promotion and discount analytics (lift/cannibalization/halo/pantry-loading) (frontier)
- subscription/SaaS pricing analytics (packaging/price-volume-mix/expansion) (frontier)
- price-volume-mix bridge and margin analytics (frontier)
- price A/B testing and geo price tests (fairness/ethics/legal) (frontier)
Augmented Analytics and LLM-Assisted Analysis ●
- Augmented analytics and agentic analytics (Gartner) (frontier)
- Conversational BI and NLQ (frontier)
- Text-to-SQL (schema linking, self-correction, Spider/BIRD benchmarks) (frontier)
- Analytics agents (plan-query-analyze-narrate, code interpreter) (frontier)
- Automated insight generation and NLG narratives (frontier)
- RAG over structured plus unstructured analytical context (hybrid SQL+vector) (frontier)
- Evaluation, trust and governance for LLM-produced numbers (frontier)
Knowledge Graphs and Semantic Analytics ●
- Two graph data models (LPG vs RDF triple store, RDF-star) (frontier)
- Semantic web stack (RDF, RDFS, OWL 2, SPARQL, SHACL, named graphs) (frontier)
- OWL inference vs SHACL validation (open- vs closed-world) (frontier)
- Ontology and taxonomy engineering (SKOS, upper ontologies, ODPs, schema.org) (frontier)
- KG construction (entity/relation extraction, resolution, linking, R2RML/RML, OBDA, LLM-assisted) (frontier)
- Querying, reasoning and analytics (SPARQL vs Cypher vs ISO GQL, materialisation) (frontier)
- Enterprise KGs, data fabric and catalogs-as-graphs (frontier)
- GraphRAG and semantic retrieval for grounded entity-centric analytics (frontier)
A/B Testing and Causal Inference 1
A/B Testing Fundamentals ●
- Sample Size and Power Analysis MDE (frontier)
- Multiple Testing Bonferroni BH FDR (frontier)
- Sequential Testing mSPRT O'Brien-Fleming (frontier)
- Multi-Armed Bandits Thompson UCB (frontier)
- CUPED Variance Reduction (frontier)
- Network Effects SUTVA Switchback (frontier)
- Pearl Causal Hierarchy DAGs (frontier)
- Backdoor Frontdoor Criterion (frontier)
- Propensity Score Matching IPTW Doubly Robust (frontier)
- Regression Discontinuity Sharp Fuzzy (frontier)
- Instrumental Variables Exclusion Restriction LATE (frontier)
- Difference-in-Differences Parallel Trends (frontier)
- Synthetic Control (frontier)
- Heterogeneous Treatment Effects Causal Forests Uplift (frontier)
- Online Experimentation Platforms (frontier)
Data Acquisition and Sampling ●
- Data Sources Taxonomy (frontier)
- APIs and Pagination (frontier)
- Web Scraping (frontier)
- Database Extraction and CDC (frontier)
- Streaming Ingest (frontier)
- ETL vs ELT (frontier)
- Surveys and Primary Collection (frontier)
- Sampling Methodology (frontier)
- Sample Size Determination (frontier)
- Data Contracts (frontier)
- File Formats (frontier)
Data Analysis Foundations and Theory ● 6
Data Analysis Definitions and Scope 3
Data Analysis vs Analytics vs Data
Analysis vs Synthesis
Quantitative vs Qualitative Analysis
Measurement Theory 4
Levels of Measurement 4
Nominal Scale
Ordinal Scale
Interval Scale
Ratio Scale
Discrete vs Continuous Variables
Reliability and Validity
Operationalization and Constructs
Probability Theory 8
Random Variables
Probability Mass and Density Functions
Probability Distributions 5
Normal Distribution
Binomial Distribution
Poisson Distribution
Exponential Distribution
Uniform Distribution
Joint Marginal Conditional Probability
Bayes Theorem
Law of Large Numbers
Central Limit Theorem
Expectation Variance Covariance
Statistical Inference Foundations 4
Population vs Sample
Sampling Distributions and Standard Error
Frequentist vs Bayesian Paradigms
Estimation Theory
Information Theory
Epistemology of Data 3
Correlation vs Causation
Inductive vs Deductive Reasoning
Reproducibility and Replicability
Data Analysis Lifecycle ● 2
Process Frameworks 5
CRISP-DM
KDD Process
SEMMA
OSEMN
TDSP
Problem Framing 2
Business Research Question Definition
Hypothesis Formulation
Data Analysis Tools and Languages
- Python pandas Polars DuckDB (frontier)
- NumPy SciPy scikit-learn (frontier)
- R tidyverse data.table arrow (frontier)
- SQL Modern Dialects Window Functions CTEs (frontier)
- Spark PySpark Databricks Photon (frontier)
- dbt Analytics Engineering (frontier)
- Jupyter JupyterLab VS Code (frontier)
- Marimo Reactive Notebooks (frontier)
- Quarto Polyglot Reports (frontier)
- Reproducible Analysis Stack (frontier)
- Notebook Anti-patterns (frontier)
- Performance Benchmarks pandas vs Polars vs DuckDB (frontier)
Data Cleaning and Preparation
- Missing Data MCAR MAR MNAR (frontier)
- Imputation Methods (frontier)
- Outlier Detection (frontier)
- Type Coercion (frontier)
- Deduplication and Record Linkage (frontier)
- Normalization and Scaling (frontier)
- Categorical Encoding (frontier)
- Schema Validation (frontier)
- Feature Engineering Basics (frontier)
- Text Cleaning (frontier)
- Imbalanced Datasets (frontier)
Data Ethics and Privacy 1
- Bias Types Selection Measurement Label Sampling (frontier)
- Fairness Metrics Demographic Parity Equalized Odds Calibration (frontier)
- Fairness Impossibility Theorems (frontier)
- Fairlearn AIF360 What-If Tool (frontier)
- GDPR Purpose Limitation Right to Erasure (frontier)
- CCPA CPRA Sensitive Personal Information (frontier)
- HIPAA PHI Safe Harbor (frontier)
- EU AI Act Risk Tiers 2024-2026 (frontier)
- Differential Privacy Epsilon Delta (frontier)
- k-anonymity l-diversity t-closeness (frontier)
- IRB Common Rule Belmont (frontier)
- Model Cards Datasheets Data Statements (frontier)
- AI Alignment for Analysis Pipelines (frontier)
Exploratory Data Analysis
- Tukey EDA Philosophy (frontier)
- Univariate Analysis (frontier)
- Bivariate Analysis (frontier)
- Multivariate Analysis (frontier)
- Distribution Checking QQ Plots (frontier)
- Time-Series EDA (frontier)
- Automated EDA Tools (frontier)
- HARKing Garden of Forking Paths (frontier)
- Pre-Registration (frontier)
Machine Learning ● 3
Deep Reinforcement Learning Foundations ●
- Markov Decision Processes (frontier)
- Dynamic Programming (frontier)
- Model-Free Prediction and Control (frontier)
- Temporal-Difference Learning (frontier)
- Value-Based Deep RL (DQN/Rainbow) (frontier)
- Policy Gradient Methods (frontier)
- Actor-Critic Methods (A2C/GAE/TRPO/PPO) (frontier)
- Continuous Control (DDPG/TD3/SAC) (frontier)
- Maximum-Entropy RL (frontier)
- Model-Based RL (MuZero/Dreamer) (frontier)
- Offline RL (CQL/IQL/Decision Transformer) (frontier)
- Exploration Strategies (RND/curiosity) (frontier)
- Reward Shaping & Reward Hacking (frontier)
- Multi-Agent RL (frontier)
Learned / ML-based Query Optimization
- Why cardinality estimation is the optimizer's hardest sub-problem (frontier)
- Query-driven learned cardinality estimation (MSCN) (frontier)
- Data-driven learned cardinality estimation (DeepDB, Naru, NeuroCard) (frontier)
- Pessimistic/bound-based estimation (AGM/PANDA/SafeBound/LpBound) (frontier)
- Learned cost models (QPPNet, tree-LSTM, tree-CNN, zero-shot) (frontier)
- Neo end-to-end learned optimizer (frontier)
- RL join ordering (ReJOIN, DQ, Balsa) (frontier)
- Replacement-vs-steering spectrum (Bao, Lero, AutoSteer) (frontier)
- Instance-optimized / self-driving databases (Peloton/NoisePage) (frontier)
- OtterTune knob tuning and shutdown (frontier)
- Learned indexes (RMI) adjacent (frontier)
- Benchmarks (JOB/IMDB, STATS-CEB, JOB-Complex) (frontier)
- q-error vs P-Error / plan regret (frontier)
- When learned optimization fails (frontier)
- Production status as of 2026 (QO-Advisor shutdown, ByteCard) (frontier)
ML Model Monitoring ●
- Drift Taxonomy (data/covariate, concept, prediction/output, label/prior, feature drift) (frontier)
- Drift Detection Tests (PSI, KL/JS divergence, KS, Chi-square, Wasserstein/EMD, L-infinity, MMD, C2ST) (frontier)
- Sequential/Streaming Concept-Drift Detectors (DDM, EDDM, ADWIN, Page-Hinkley, CUSUM) (frontier)
- Performance Monitoring with Delayed/Absent Ground Truth (proxy metrics, two-loop monitoring, label lag) (frontier)
- Performance Estimation Without Labels (NannyML CBPE, DLE, M-CBPE) (frontier)
- Training-Serving Skew Detection (frontier)
- Slice/Segment-Based Performance Monitoring and Fairness Drift (frontier)
- Input Outlier/Adversarial Detection (Alibi Detect) (frontier)
- Alerting, Retraining Triggers, and the Monitoring->Retraining Loop (frontier)
- Model-Monitoring Tooling (Evidently, Arize, Fiddler, WhyLabs/whylogs, NannyML, Seldon/Alibi Detect, SageMaker Model Monitor, Vertex AI Model Monitoring, MLflow) (frontier)
- Model Monitoring vs Data Observability vs LLM Observability (frontier)
- ML Taxonomy (frontier)
- Bias-Variance Tradeoff (frontier)
- Regularization (frontier)
- Deep Learning (frontier)
- CNNs (frontier)
- RNNs (frontier)
- Transformers (frontier)
- Foundation Models (frontier)
- LLM Landscape 2026 (frontier)
- Hyperparameter Tuning (frontier)
- Bayesian Optimization (frontier)
- Optuna (frontier)
- Ray Tune (frontier)
- Model Evaluation (frontier)
- Precision Recall F1 (frontier)
- ROC AUC (frontier)
- Regression Metrics (frontier)
- LLM Evaluation (frontier)
- HELM (frontier)
- MMLU (frontier)
- MT-Bench (frontier)
- Chatbot Arena (frontier)
- SWE-bench (frontier)
- LLM-as-Judge (frontier)
- MLOps (frontier)
- Drift Detection (frontier)
- Train-Serve Skew (frontier)
- MLflow (frontier)
- Weights and Biases (frontier)
- Feature Stores (frontier)
- Deployment Patterns (frontier)
- Retraining Triggers (frontier)
- Reproducibility (frontier)
Statistical Modeling 1
- Linear Regression (frontier)
- Logistic Regression (frontier)
- GLMs (frontier)
- Regularization Ridge Lasso ElasticNet (frontier)
- Classification LDA QDA Naive Bayes (frontier)
- Clustering k-means DBSCAN GMM (frontier)
- Time Series ARIMA Prophet (frontier)
- Mixed-Effects Models (frontier)
- Model Selection AIC BIC CV (frontier)
- Model Interpretation SHAP (frontier)
- Bayesian Modeling Stan PyMC (frontier)
DevOps, Infrastructure & Observability ● 14
systemd (init system & service manager) ●
- Unit & object model (service/socket/target/timer/mount/slice/scope/path/device types, Type= readiness) (frontier)
- Dependency & ordering semantics (Wants/Requires/Requisite/BindsTo/PartOf, After/Before, drop-ins, presets, generators) (frontier)
- systemd-journald (Storage= volatile/persistent/auto/none, rotation/vacuum, rate-limiting, forwarding, Forward Secure Sealing, journal namespaces, remote journals) (frontier)
- cgroup-v2 resource control (slice/scope tree, CPUWeight/CPUQuota/AllowedCPUs, MemoryMin/Low/High/Max ladder, IOWeight, TasksMax, Delegate) (frontier)
- systemd-oomd (PSI-driven userspace OOM, ManagedOOMSwap/ManagedOOMMemoryPressure, oomd.conf) (frontier)
- System & configuration extensions (systemd-sysext /usr+/opt, systemd-confext /etc, DDIs/dm-verity, extension-release matching) (frontier)
- Portable services (portablectl, systemd-portabled, security profiles) (frontier)
- Execution sandbox (ProtectSystem/PrivateTmp/DynamicUser/CapabilityBoundingSet/SystemCallFilter, systemd-analyze security) (frontier)
Linux Kernel Architecture & Scheduling — CFS/EEVDF, Syscall ABI, Kernel Modules ●
- Monolithic kernel architecture (ring 0/3, kernel vs user space, major subsystems) (frontier)
- CFS scheduler (vruntime, weight from nice, rb-tree) (frontier)
- EEVDF scheduler (lag, eligibility, virtual deadline, request size/time slice, Linux 6.6) (frontier)
- Scheduling-class hierarchy (stop/dl/rt/fair/idle) and policies (SCHED_OTHER/FIFO/RR/DEADLINE/IDLE) (frontier)
- Preemption models (PREEMPT_NONE/VOLUNTARY/FULL/LAZY) and PREEMPT_RT (frontier)
- Syscall ABI (x86-64 calling convention, syscall instruction, rax/rdi..r9, vDSO) (frontier)
- Syscall entry path (SYSCALL_DEFINE, sys_call_table dispatch, pt_regs, seccomp/ptrace interception) (frontier)
- Loadable kernel modules (insmod/modprobe/finit_module, module_init/exit, depmod) (frontier)
- Symbol export and GPL boundary (EXPORT_SYMBOL vs EXPORT_SYMBOL_GPL) (frontier)
- Module ABI safety (vermagic, CONFIG_MODVERSIONS CRC, unstable internal ABI) (frontier)
- Module signing (CONFIG_MODULE_SIG, Secure Boot/MOK) and Kbuild out-of-tree builds (frontier)
Linux Filesystems & Storage — ext4/XFS/Btrfs/ZFS, LVM, Block Layer & I/O Schedulers ●
- VFS, page cache, and the writeback path (vm.dirty_ratio/dirty_background_ratio throttling, fsync/fdatasync, O_DIRECT) (frontier)
- ext4 — extents, jbd2 journaling (ordered/journal/writeback), delayed allocation, htree, resize2fs/e2fsck (frontier)
- XFS — allocation groups, CIL/delayed-logging journal, grow-only, xfs_repair vs auto log replay, xfs_scrub online fsck (RHEL default) (frontier)
- Btrfs — copy-on-write, subvolumes/snapshots, b-tree, checksums, integrated RAID, the RAID5/6 write-hole caveat (not production) (frontier)
- ZFS — zpool/vdev/RAID-Z hierarchy, end-to-end checksums + self-heal, ARC/L2ARC, ZIL/SLOG, scrub, CDDL out-of-tree module (frontier)
- LVM and device-mapper — PV/VG/LV, physical extents, dm-linear/striped/snapshot/thin/cache/crypt, thin provisioning, mdadm software RAID (frontier)
- Multi-queue block layer (blk-mq) and I/O schedulers — none/mq-deadline/kyber/bfq, scheduler-per-device-class (frontier)
- Block queue tunables — nr_requests, read_ahead_kb, rotational, add_random (frontier)
- TRIM/discard — fstrim.timer batched vs inline discard mount option (frontier)
- Filesystem repair & integrity — xfs_repair, e2fsck, btrfs scrub/check, zpool scrub/replace, fsck workflow (frontier)
Immutable & Atomic Linux Distributions — OSTree/rpm-ostree, bootc/CoreOS, NixOS, openSUSE MicroOS ●
- Atomic/immutable shared model (transactional A/B-vs-snapshot updates, read-only /usr+root, mutable /etc+/var, rollback) (frontier)
- OSTree + rpm-ostree (Fedora Silverblue/Kinoite/Atomic — content-addressed deployments, package layering, container-native ostree) (frontier)
- bootc / bootable containers (Fedora CoreOS, RHEL image mode — OCI image as OS, Containerfile, bootc switch/upgrade, bootc-image-builder) (frontier)
- NixOS (functional /nix/store, declarative configuration.nix, generations, nixos-rebuild + rollback) (frontier)
- openSUSE MicroOS/Aeon/SLE Micro (transactional-update over Btrfs + snapper) (frontier)
- Application model: Flatpak + toolbx/distrobox (frontier)
- Distro selection by use case (desktop/server/K8s node/edge) (frontier)
- Anti-patterns and failed-update/rollback troubleshooting (frontier)
Linux io_uring — Async I/O Rings, liburing, Registered Resources & Security-Disable Saga ●
- The two-ring shared-memory model (SQ + CQ, SQE/CQE structs, head/tail, indirection array) (frontier)
- The three syscalls (io_uring_setup / io_uring_enter / io_uring_register) (frontier)
- liburing userspace library (queue_init, get_sqe, prep_*, submit, wait_cqe, cqe_seen, for_each_cqe) (frontier)
- Submission/completion modes (default interrupt-driven, IORING_SETUP_SQPOLL kernel poller, IORING_SETUP_IOPOLL busy-poll, COOP/DEFER_TASKRUN/SINGLE_ISSUER) (frontier)
- Registered/fixed buffers + READ_FIXED/WRITE_FIXED and O_DIRECT win (frontier)
- Registered/fixed files + IOSQE_FIXED_FILE and direct descriptors (frontier)
- Provided buffer rings (IORING_REGISTER_PBUF_RING, kernel-picked buffer IDs) (frontier)
- SQE ordering and chaining (IOSQE_IO_LINK/HARDLINK/IO_DRAIN/ASYNC/CQE_SKIP_SUCCESS) (frontier)
- Multishot operations (multishot accept/recv/poll, IORING_CQE_F_MORE, re-arming) (frontier)
- Zero-copy networking (IORING_OP_SEND_ZC two-CQE F_MORE/F_NOTIF 6.0, zero-copy receive 6.15, NAPI busy-poll) (frontier)
- Kernel-version feature timeline (5.1 introduction -> 6.x maturation) (frontier)
- The 2023-2025 security-disable saga (Google 60%-of-exploits, ChromeOS/Android disable, Docker/containerd seccomp default, why seccomp does not filter ops in the ring) (frontier)
- Kernel-side controls (io_uring_disabled sysctl, IORING_SETUP_R_DISABLED + IORING_REGISTER_RESTRICTIONS allowlist, task-level restrictions, Curing rootkit) (frontier)
Linux Sandboxing & Confinement — seccomp-bpf, Landlock, gVisor, Kata, Firecracker ●
- seccomp-bpf syscall filtering (cBPF over seccomp_data, eight RET actions, no_new_privs, TSYNC, SECCOMP_RET_USER_NOTIF notifier) (frontier)
- Landlock unprivileged self-sandboxing LSM (ABI v1-v6, filesystem/REFER/TRUNCATE/network/ioctl/scoped-IPC rights, best-effort downgrade) (frontier)
- LSM framework + capabilities + SELinux/AppArmor/BPF-LSM context (frontier)
- gVisor user-space kernel (Sentry, Gofer/9P + Directfs, runsc, ptrace->Systrap->KVM platforms) (frontier)
- Kata Containers VM-isolated OCI containers (shim/agent/guest-kernel/rootfs, QEMU vs Cloud Hypervisor vs Firecracker, TDX/SEV-SNP, runtime-rs) (frontier)
- Firecracker minimal microVM monitor (5-device model, Jailer, ~125ms boot/<5MiB, Lambda/Fargate) (frontier)
- Unprivileged userspace sandboxes (bubblewrap, nsjail, firejail) (frontier)
- Isolation-vs-performance decision model for choosing a boundary (frontier)
Linux Memory Management & NUMA — Virtual Memory, Paging, Reclaim, OOM, Hugepages, NUMA Tuning ●
- Virtual memory & demand paging (page tables/TLB, minor vs major faults, copy-on-write, page cache, anonymous vs file-backed, swap & vm.swappiness) (frontier)
- Memory overcommit (vm.overcommit_memory heuristic/always/strict, overcommit_ratio, CommitLimit/Committed_AS) (frontier)
- Reclaim machinery (kswapd vs direct reclaim, min/low/high watermarks, vm.min_free_kbytes, active/inactive LRU, MGLRU, PSI memory pressure) (frontier)
- The OOM killer (oom_badness, oom_score_adj -1000..+1000, panic_on_oom, dmesg forensic) (frontier)
- cgroup-v2 memcg OOM (memory.max/high/low/min, memory.swap.max, memory.oom.group, memory.events, memory.pressure, memory.reclaim) (frontier)
- systemd-oomd (PSI + swap driven proactive userspace OOM, ManagedOOMMemoryPressure/Swap) (frontier)
- Transparent hugepages (enabled always/madvise/never, defrag, khugepaged pages_to_scan/max_ptes_none, MADV_HUGEPAGE/NOHUGEPAGE/COLLAPSE) (frontier)
- Multi-size THP / mTHP & folios (hugepages-<size>kB/enabled inherit, per-size stats, THP shrinker shrink_underused) (frontier)
- Explicit hugepages (hugetlbfs, vm.nr_hugepages, 2M/1G hugepagesz boot reserve, MAP_HUGETLB, hugetlb cgroup controller) (frontier)
- NUMA topology & node distance (numactl -H, lscpu, lstopo, /sys/devices/system/node) (frontier)
- AutoNUMA balancing (kernel.numa_balancing, page migration & scheduler bias) (frontier)
- NUMA memory policy (numactl --membind/--interleave/--preferred/--localalloc, set_mempolicy/mbind, MPOL_BIND/INTERLEAVE/PREFERRED/LOCAL) (frontier)
- zone_reclaim_mode & numastat (numa_hit/miss/foreign, local_node/other_node) (frontier)
- Container/k8s NUMA & memory limits (cpuset.mems, Topology Manager, Guaranteed QoS, exit 137) (frontier)
Linux Boot & Init — UEFI/Secure Boot, GRUB, initramfs/dracut, Early Userspace ●
- UEFI firmware, the ESP, and boot entries (BootOrder/Boot#### EFI vars, efibootmgr, efivarfs, PEI/DXE/BDS, fallback BOOTX64.EFI) (frontier)
- Secure Boot signature chain (PK/KEK/db/dbx, Microsoft-signed shim, distro embedded cert, MOK/MokManager/mokutil, SBAT generation-based revocation, kernel lockdown) (frontier)
- GRUB 2 (boot.img/core.img stages, grubx64.efi, generated grub.cfg via grub-mkconfig/update-grub, menuentry linux/initrd, BLS Type 1 entries, grubby/kernel-install) (frontier)
- systemd-boot / sd-boot (UEFI-only, bootctl, auto-discovery of BLS Type1 + Type2 UKIs, loader.conf) (frontier)
- Unified Kernel Image (UKI) — systemd-stub, ukify, PE sections .linux/.initrd/.cmdline, signed cmdline+initrd, UAPI.5 (frontier)
- Kernel command line (root=, rd.* dracut params, init=/systemd.unit handoff, diagnostics quiet/loglevel/nomodeset) (frontier)
- initramfs/initrd early userspace (why it exists, CPIO-into-tmpfs, dracut build + hostonly vs no-hostonly, dracut modules, config) (frontier)
- Two initramfs execution models (systemd-in-initrd targets + /sysroot contract vs legacy dracut /init hook pipeline cmdline..pre-pivot..cleanup) (frontier)
- The switch_root / pivot_root handoff to PID 1 and shutdown jump-back to /run/initramfs/shutdown (frontier)
- Measured boot & TPM-bound unlock (TPM2 PCR 4/7/11/12/13, systemd-cryptenroll, systemd-measure signed PCR11, systemd-pcrlock) (frontier)
- Boot-failure troubleshooting (dracut emergency shell, rd.break stages, VFS unable to mount root, grub rescue, rebuilding a broken initramfs) (frontier)
Linux Virtualization — KVM, QEMU, libvirt, virtio & microVMs ●
- KVM in-kernel hypervisor (/dev/kvm ioctl API — KVM_CREATE_VM/VCPU/RUN, Intel VT-x/VMX root vs non-root, AMD-V/SVM, EPT/NPT two-dimensional paging, VM exits, posted interrupts/APICv, one-thread-per-vCPU, nested virt) (frontier)
- QEMU userspace VMM & device model (accelerators kvm/tcg/hvf, machine types q35/pc/virt/microvm versioned, -machine/-cpu/-device/-drive/-netdev model, OVMF/UEFI firmware, qcow2 vs raw, io_uring block backend) (frontier)
- virtio paravirtualized device framework (virtqueues/vrings split vs packed, feature negotiation, transports virtio-pci/-mmio/-ccw, device family net/blk/scsi/fs/gpu/balloon/vsock/rng) (frontier)
- virtio data-plane acceleration ladder (QEMU-emulated → vhost-net/vhost-scsi kernel → vhost-user DPDK/SPDK → vDPA hardware offload) (frontier)
- libvirt management layer (domain XML + virsh, the modular daemons virtqemud/virtnetworkd/virtnodedevd/virtstoraged/virtsecretd, virtproxyd, default NAT network + storage pools) (frontier)
- microVMs (Firecracker 5-device model + jailer + ~125ms boot/<5MiB, Cloud Hypervisor, rust-vmm crates, QEMU microvm machine type, Kata wrapping) (frontier)
- Device assignment (VFIO/vfio-pci, IOMMU groups + VT-d/AMD-Vi, SR-IOV PF/VF, GPU passthrough, mediated devices mdev) (frontier)
- Live migration (pre-copy iterative + stop-and-copy, post-copy demand fault, CPU-model/machine-type compatibility, VFIO device migration) (frontier)
- Confidential VMs (AMD SEV/SEV-ES/SEV-SNP via PSP, Intel TDX/SEAM Trust Domains, guest memory encryption + integrity + remote attestation) (frontier)
- VM performance tuning (host-passthrough vs host-model, 1:1 CPU pinning, NUMA affinity, 2M/1G hugepages, multiqueue virtio-net, vhost, iothreads, balloon/KSM overcommit) (frontier)
Linux Package Management & Software Building — apt/dpkg, dnf/rpm, pacman, from-source & kernel build ●
- Shared package model (packages, dependencies, repositories, transactions, signing, explicit-vs-dependency) (frontier)
- apt/dpkg on Debian/Ubuntu (APT 3.0 solver3, deb822 + Signed-By keyrings, apt-mark hold, dpkg low-level) (frontier)
- dnf/rpm on Fedora/RHEL (dnf5, transaction history undo/rollback, gpgcheck, rpm -V/--rebuilddb, RHEL core-package caveat) (frontier)
- pacman on Arch (-Syu vs the partial-upgrade hazard, flag grammar, orphans, archlinux-keyring desync, PKGBUILD/makepkg/AUR) (frontier)
- Universal formats — Flatpak/Snap/Nix (dependency-bundled, cross-distro tradeoffs) (frontier)
- Building from source (autotools configure/make, CMake, Meson/Ninja, prefix isolation, checkinstall, GNU Stow, ldconfig) (frontier)
- Linux kernel build (menuconfig/localmodconfig/olddefconfig, make -j, modules_install, bzImage, initramfs + GRUB, fallback boot) (frontier)
- Cross-distro troubleshooting (NO_PUBKEY, dpkg interrupted, broken/held deps, rpmdb corruption, pacman PGP signature, missing -dev headers, kernel won't boot) (frontier)
eBPF for Linux Observability, Networking & Security ●
- eBPF VM, verifier, JIT & maps (frontier)
- Helpers and kfuncs (frontier)
- Program & attach types (kprobe/uprobe/tracepoint/fentry/XDP/tc/LSM) (frontier)
- CO-RE, BTF, vmlinux.h & libbpf portability (frontier)
- bpftrace tracing language (frontier)
- bcc (BPF Compiler Collection) tools (frontier)
- Development frameworks (libbpf, cilium/ebpf Go, aya Rust, eunomia-bpf) (frontier)
- Cilium eBPF CNI & kube-proxy replacement (XDP/tc/socket hooks, DSR, Maglev) (frontier)
- Hubble flow visibility (frontier)
- eBPF runtime security (BPF LSM, Tetragon, Falco, KubeArmor) (frontier)
- Continuous profiling (Parca, Pixie) (frontier)
- Ring buffer vs per-CPU perf buffer event streaming (frontier)
- eBPF verifier limits & troubleshooting (frontier)
Linux Mandatory Access Control & Privilege — SELinux, AppArmor & Capabilities ●
- LSM framework (hooks before each kernel access, exclusive vs stackable, SELinux/AppArmor/Smack/TOMOYO/Yama/Landlock/IPE/LoadPin/SafeSetID/BPF-LSM modules, lsm= boot stacking, only one exclusive MAC) (frontier)
- SELinux label model (user:role:type:level contexts, Type Enforcement as the core, RBAC, MLS/MCS, targeted vs mls policy) (frontier)
- SELinux operations (enforcing/permissive/disabled modes, domain transitions, booleans, semanage fcontext/port labeling, restorecon vs chcon, getenforce/setenforce, ls -Z/ps -Z/id -Z) (frontier)
- SELinux troubleshooting loop (AVC denials, ausearch -m avc, sealert, audit2allow -M as last resort, dontaudit semodule -DB) (frontier)
- AppArmor path-based profiles (enforce vs complain/learning, abstractions/includes, aa-genprof/aa-logprof/aa-enforce/aa-status, path-vs-label trade-off, multi-path bypass caveat) (frontier)
- Linux capabilities — five thread sets (permitted/effective/inheritable/bounding/ambient) and the execve() transformation formula (frontier)
- File capabilities + securebits + no_new_privs (security.capability xattr, setcap/getcap, SECBIT_*, prctl PR_SET_NO_NEW_PRIVS) (frontier)
- Dangerous capabilities (CAP_SYS_ADMIN, CAP_DAC_OVERRIDE, CAP_SETUID/SETGID, CAP_NET_ADMIN, CAP_NET_BIND_SERVICE, CAP_SYS_MODULE/PTRACE/BPF) (frontier)
- Container & Kubernetes composition (cap-drop ALL + add, container_t/MCS categories, seLinuxOptions, docker-default/appArmorProfile, seccomp RuntimeDefault, Pod Security Standards Baseline/Restricted) (frontier)
DNS Caching
- Enterprise / ISP Resolvers (frontier)
- Edge / Local Resolvers (frontier)
- Cloud Native / Ad-blocking (frontier)
- Query Tools (frontier)
- Performance (frontier)
- Packet Analysis (frontier)
- Logging Protocols (frontier)
- Visualization (frontier)
- Deployment (frontier)
- Maintenance (frontier)
- Resource Sizing (frontier)
- Architecture (frontier)
- Security (frontier)
- Operations (frontier)
- Best Practices (frontier)
- Frontier (frontier)
- Encrypted DNS (frontier)
- Advanced Routing (frontier)
- Cloud Native (frontier)
- Resilience (frontier)
- DDR (frontier)
- Multi-CDN Steering (frontier)
- Ambient Mesh DNS (frontier)
- DGA Detection (ML) (frontier)
- Serve Stale (frontier)
Cross-Computer Input Sharing (software KVM + hardware KVM / DDC-CI switching) 3
- Software-KVM lineage & protocol compat (Synergy 2001 -> Barrier 2018 -> Input Leap 2021 -> Deskflow upstream 2024) (frontier)
- Deskflow macOS setup (brew tap, quarantine xattr, Accessibility/Input Monitoring/Local Network TCC) (frontier)
- Server text config & hotkey switching (screens/links/aliases/options; keystroke = switchToScreen/switchInDirection/lockCursorToScreen) (frontier)
- lan-mouse (Rust/DTLS) and commercial/legacy alternatives (ShareMouse, teleport) (frontier)
- DDC/CI input switching (MCCS VCP 0x60, m1ddc, BetterDisplay CLI, ddcutil quirks) (frontier)
- Hardware hotkey KVMs & EDID emulation (frontier)
- Full-desk orchestration (m1ddc + HID++ + blueutil over SSH; InputSwitch pattern) (frontier)
Apple Universal Control (Continuity edge-crossing input sharing)
- Requirements & device matrix (same Apple Account/2FA, BT+Wi-Fi+Handoff, 10 m, max 3 devices, model blacklist) (frontier)
- Ensemble daemon layer (UniversalControl process, com.apple.ensemble LaunchAgent, UniversalControl.framework, rapportd) (frontier)
- AWDL transport & session model (Controller/Target, Hot Zone, Sync Barrier, XIDs, EVNT/SYNC/DRAG/CLIP) (frontier)
- Unified-log analysis (com.apple.universalcontrol + com.apple.rapport subsystems) (frontier)
- com.apple.universalcontrol defaults keys (Disable, DisableMagicEdges, -currentHost/ByHost) & allowUniversalControl MDM (frontier)
- The scripting gap (no API/CLI/AppleScript/Shortcuts; synthesized events don't cross the edge) (frontier)
- Workaround classes (edge pre-arrangement, Control Center GUI-scripting, killall/pkill -HUP reset primitives) (frontier)
- Failure modes & reset ladder (one-way links, sleep drops, VPN/awdl0 interference, Sidecar conflict) (frontier)
Logitech HID++ 2.0 Multi-Host Switching (Easy-Switch, feature 0x1814)
- HID++ 2.0 framing & IRoot feature discovery (frontier)
- Feature 0x1814 changeHost (get_host_info/set_current_host/cookies, ENHANCED_HOST_SWITCH) (frontier)
- Feature 0x1815 hostsInfo (slot status, bus type, host names) (frontier)
- Undocumented Easy-Switch 0x1814 notification & discriminator filters (frontier)
- macOS HID access paths (0xFF43/0x0202 BT vs 0xFF00 receiver, TCC Input Monitoring) (frontier)
- Tool landscape (logi-gate, Optune, mxswitch, CleverSwitch, logi_mx_auto_switch, Solaar, logitech-flow-kvm, hidapitester) (frontier)
- Orchestration patterns (hotkeys, corner triggers, keyboard-follower daemons, push-only rule) (frontier)
macOS Programmatic Input Control (CGEvent synthesis, event taps, cursor warping, TCC gates, remapping & pointer tuning)
- macOS input event pipeline (HID→IOKit→WindowServer→CGEvent→NSEvent) (frontier)
- CGEvent synthesis (mouse/keyboard/scroll, CGEventPost, tap locations) (frontier)
- Event taps (CGEventTapCreate, active vs listen-only, timeout re-enable) (frontier)
- Cursor positioning (CGWarpMouseCursorPosition, suppression interval, CGAssociateMouseAndMouseCursorPosition) (frontier)
- TCC gates (Accessibility vs Input Monitoring vs none; secure input mode; tccutil) (frontier)
- Scripting surfaces (cliclick, MouseTools, Hammerspoon, AppleScript System Events, PyObjC/pyautogui) (frontier)
- Karabiner-Elements architecture (grabber, DriverKit virtual HID, complex_modifications) (frontier)
- hidutil UserKeyMapping (TN2450, persistence via LaunchAgent, per-device matching) (frontier)
- Pointer acceleration model (HIDPointerAcceleration, mouse.scaling, Sonoma linear toggle) (frontier)
- Pointer-tuning tools (LinearMouse, Mos, SteerMouse, USB Overdrive, BetterTouchTool) (frontier)
Finance, Markets & Blockchain 3
Trading and market structure, blockchain protocols, and personal finance.
Trading and Investing — Active Trading & How Financial Markets Work (Family Root) ● 2
- stock-and-equity-trading (frontier)
- options-trading-and-strategies (frontier)
- derivatives-futures-and-swaps (frontier)
- technical-analysis (frontier)
- trading-strategies-and-styles (frontier)
- algorithmic-and-quant-trading (frontier)
- crypto-and-digital-asset-trading (frontier)
- forex-and-currency-trading (frontier)
- trading-risk-management (frontier)
- portfolio-theory-and-asset-allocation (frontier)
- trading-psychology-and-behavioral-finance (frontier)
- fixed-income-and-bond-markets (frontier)
- market-microstructure-and-execution (frontier)
- defi-and-onchain-trading (frontier)
- ai-and-ml-for-trading (frontier)
- trading-regulation-compliance-and-taxes (frontier)
On-chain and FX market mechanics
Market mechanics and trading infrastructure 1
Blockchain protocols 2
Bitcoin protocol and ecosystem ●
- UTXO transaction model and Bitcoin Script (frontier)
- Block structure, Proof-of-Work mining and difficulty (frontier)
- Bitcoin monetary policy and the 21M issuance cap (frontier)
- Mempool, fee estimation and fee-bumping (RBF, CPFP, TRUC) (frontier)
- SegWit, Taproot and soft-fork activation (frontier)
- Lightning Network payment channels and HTLC routing (frontier)
- Ordinals, inscriptions, BRC-20 and Runes (frontier)
- BitVM and the Bitcoin L2/restaking landscape (Babylon) (frontier)
- Bitcoin covenants debate (OP_CTV, OP_CAT, APO) (frontier)
- Running a Bitcoin node and wallet custody models (frontier)
Ethereum Consensus (Proof of Stake): Protocol-User Technical Reference ●
Consumer Finance ● 9
Student Loans ●
- Federal vs private loans (frontier)
- Loan types (Direct Sub/Unsub, PLUS, consolidation) (frontier)
- Interest and capitalization (frontier)
- Loan servicers (frontier)
- Repayment plans (Standard/Graduated/Extended) (frontier)
- IDR family (SAVE/IBR/PAYE/ICR) and RAP (frontier)
- Forgiveness & discharge (PSLF/IDR/Teacher/TPD) (frontier)
- Deferment vs forbearance (frontier)
- Delinquency and default (frontier)
- Default recovery (rehab/consolidation/Fresh Start) (frontier)
- Administrative wage garnishment & Treasury offset (frontier)
- FAFSA and borrowing wisely (frontier)
Personal Banking ●
- Deposit account types (frontier)
- High-yield savings and CDs (frontier)
- APY and Truth in Savings (Reg DD) (frontier)
- Banks vs credit unions (frontier)
- FDIC vs NCUA deposit insurance (frontier)
- Neobank/fintech pass-through risk (Synapse) (frontier)
- Overdraft/NSF and Reg E opt-in (frontier)
- Payments (ACH/wire/Zelle) and authorized scams (frontier)
- ChexSystems and second-chance accounts (frontier)
- Account fees, joint accounts, unclaimed property (frontier)
Personal Income Taxes ●
- Filing statuses (frontier)
- Marginal vs effective brackets (frontier)
- Standard vs itemized deduction (frontier)
- Credits (EITC/CTC/education/Saver's) (frontier)
- Above-the-line adjustments (frontier)
- W-4 withholding (frontier)
- W-2 vs 1099 & self-employment tax (frontier)
- Quarterly estimated taxes (frontier)
- Capital gains basics (frontier)
- IRS process (extensions/amended/audits/payment plans) (frontier)
- Free filing (Free File/Direct File) (frontier)
- NC individual income tax (frontier)
Personal Insurance ●
- How insurance works (premium/deductible/limit/claims) (frontier)
- Auto coverages (BI/PD/collision/comprehensive) (frontier)
- UM/UIM (frontier)
- NC auto minimum limits (frontier)
- Homeowners HO-3 & renters HO-4 (frontier)
- Replacement cost vs ACV (frontier)
- Flood (NFIP) (frontier)
- Coastal NC wind / Beach Plan (NCIUA) (frontier)
- Life: term vs permanent (frontier)
- Disability: own-occ vs any-occ (frontier)
- Umbrella liability (frontier)
Health Insurance and Coverage ● 1
ACA premium tax credits/APTC & CSRs ●
- Plan cost-sharing (premium/deductible/copay/coinsurance/OOP max) (frontier)
- Network types (HMO/PPO/EPO/POS) (frontier)
- Formulary & prior authorization (frontier)
- Coverage sources (employer/ACA/Medicaid/COBRA) (frontier)
- Metal tiers & enrollment periods (frontier)
- HDHP + HSA (vs FSA) (frontier)
- Medicare Parts A-D & Medigap (frontier)
- Medicaid & NC expansion (frontier)
- Appeals & denials (frontier)
Medical Debt and Billing ●
- Itemized bill vs EOB & billing codes (frontier)
- Billing errors and disputes (frontier)
- No Surprises Act (balance billing) (frontier)
- Good-faith estimate & PPDR (frontier)
- Hospital charity care / IRS 501(r) (frontier)
- Negotiating & settling bills (frontier)
- Medical debt on credit reports (vacated 2025 rule) (frontier)
- Medical debt in collections (frontier)
- CareCredit deferred-interest traps (frontier)
- HSA/FSA & price transparency (frontier)
Budgeting and Saving ●
- Budgeting methods (50/30/20, zero-based, envelope, pay-yourself-first) (frontier)
- Tracking spending (frontier)
- Emergency fund (3-6 months) (frontier)
- Automating savings (frontier)
- Sinking funds (frontier)
- SMART financial goals (frontier)
- Budgeting on irregular income (frontier)
- Debt payoff (snowball vs avalanche) (frontier)
- Budgeting tools/apps (post-Mint) (frontier)
- Free nonprofit counseling/coaching (frontier)
Investing and Retirement ● 1
401(k)/403(b) (match/vesting/Roth vs traditional) ●
- Risk/return & diversification (frontier)
- Compounding & time horizon (frontier)
- IRA (Roth/income limits/backdoor) (frontier)
- SEP/SIMPLE (frontier)
- Index funds/ETFs/target-date funds (frontier)
- Expense ratios & fee drag (frontier)
- Dollar-cost averaging (frontier)
- Social Security claiming age (frontier)
- Investment-fraud red flags (frontier)
- Fiduciary vs commission & BrokerCheck (frontier)
Estate Planning and Wills ●
- NC will execution requirements (frontier)
- Holographic wills & self-proving affidavit (frontier)
- NC Intestate Succession Act (Ch.29) (frontier)
- Surviving-spouse elective share (G.S. 30-3.1) (frontier)
- Revocable living trust vs will (frontier)
- Durable financial POA (Ch.32C) (frontier)
- Health-care POA & living will (Ch.32A/90) (frontier)
- Beneficiary designations & POD/TOD (frontier)
- NC probate & small-estate affidavit (frontier)
- Guardianship for minors & digital assets (RUFADAA) (frontier)
- Estate/inheritance tax (NC none; federal exemption) (frontier)
Local Model Performance Evaluation: Ollama, MLX, and Hardware Architectures 1
- GDDR7 Channel Bandwidth (frontier)
- GDDR7 Peak Throughput (frontier)
- GGML Metal Kernel Dispatch Overhead (frontier)
- GGUF Alignment (frontier)
- Gemma4-12B Cross-Platform Residency and Benchmarking (frontier)
- Inference Metrics Framework: TTFT TPS and Memory Profiling (frontier)
- Inter-token Latency Jitter (frontier)
- MLX KV Cache Quantization (frontier)
- MLX Unified Memory vs eGPU GDDR7 Hardware Architecture (frontier)
- Memory Bandwidth Scaling Limit (frontier)
- Metal Command Buffer Offload (frontier)
- Multi-Token Prediction Heads (frontier)
- Ollama Architecture and GGUF Memory-Mapping (frontier)
- Quantization Block Matrix (frontier)
- Qwen3.6-35B-MLX Sizing and Throughput Profiling (frontier)
- Static Activation Buffers (frontier)
- TTFT Compute Bound Analysis (frontier)
- Thunderbolt 5 Bus Latency (frontier)
- Wired Memory Instrumentation (frontier)
- Zero-Copy Unified Pointer Passing (frontier)
Local Inference Acceleration: Memory Architectures, Metal Kernels, and Latency Optimization 1
- Asymmetric KV Cache Quantization (frontier)
- Context Threshold Compaction (frontier)
- Draft Model Amortization (frontier)
- GDDR7 Channel Bandwidth and Peak Throughput (frontier)
- GDDR7 Channel Interleaving (frontier)
- GEMM vs GEMV Scaling (frontier)
- GGML Metal Kernel Dispatch and Command Buffer Offload (frontier)
- GGUF Alignment and Quantization Block Matrix (frontier)
- Host Synchronization Bubbles (frontier)
- MLX KV Cache Quantization and Zero-Copy Pointer Passing (frontier)
- MTP Speculative Verification (frontier)
- Metal Pipeline State Caching (frontier)
- Multi-Token Prediction Heads and Speculative Decoding (frontier)
- PAM3 Modulation (frontier)
- PCIe Tunneling Protocol (frontier)
- SIMD Aligned Memory Vectorization (frontier)
- Shared Buffer Storage Modes (frontier)
- Static Scratchpad Workspace (frontier)
- Super-block Quantization Scales (frontier)
- TTFT Compute Bound Analysis and Inter-token Latency Jitter (frontier)
- Thunderbolt 5 Bus Latency and Bandwidth Scaling Limit (frontier)
- Thunderbolt Retimer Jitter (frontier)
- Wired Memory Instrumentation and Static Activation Buffers (frontier)
- Wired Page Allocation (frontier)
Local Inference Micro-Architectures: Signaling, Quantization Superblocks, and Kernel Pipeline Scheduling 1
- Affine Value Block Scaling (frontier)
- Arithmetic Intensity Thresholds (frontier)
- Asymmetric KV Cache Quantization Algorithms (frontier)
- Asynchronous Command Queue Overlap (frontier)
- Batch Matrix Amortization (frontier)
- Credit-Based Flow Control Delays (frontier)
- DRAM Latency Hiding (frontier)
- GEMM Compute Scaling vs GEMV Memory-Bandwidth Bounds (frontier)
- Hierarchical Quantization Scales (frontier)
- Key Outlier Channels (frontier)
- MTLBinaryArchive Serialization (frontier)
- Metal Pipeline State Caching and Kernel Dispatch Bubbles (frontier)
- Multi-Token Prediction Speculative Verification and Draft Amortization (frontier)
- Nyquist Frequency Attenuation (frontier)
- PAM3 Modulation and GDDR7 Channel Interleaving (frontier)
- PCIe Protocol Tunneling and Thunderbolt Retimer Jitter (frontier)
- SIMD Aligned Memory Vectorization and Super-block K-Quants (frontier)
- SIMD Cacheline Boundaries (frontier)
- Shared Buffer Storage Modes and Zero-Copy Passing (frontier)
- Speculative Acceptance Thresholds (frontier)
- Sub-microsecond Kernel Dispatch (frontier)
- TLP Encapsulation Overhead (frontier)
- Unified Coherency Protocol (frontier)
16-Bit Sub-Channel Bursts and Non-Sequential Tensor Bank Interleaving
- 16-bit Sub-channel Burst Framing (frontier)
- BC16 Turn-around Penalty (frontier)
- BL16 Burst Granularity (frontier)
- Bank Conflict Elimination in Non-Sequential Tensor Reads (frontier)
- Bank Cycle Concurrency (frontier)
- Burst Truncation and Pipelined Prefetch Stalls (frontier)
- GDDR7 Four-Channel Interleaving Architecture (frontier)
- L2 Cacheline Matching (frontier)
- MoE Routing Queueing (frontier)
- Paged KV Sub-channel Dispersion (frontier)
- Prefetch Duty Cycle (frontier)
- Pseudo-Independent Controllers (frontier)
- 16-bit Sub-channel Bursts (frontier)
MongoDB Expert Knowledge ● 29
MongoDB Atlas ● 26
MongoDB Atlas Online Archive ● 1
Archive Rules 1
DATE Criteria
- DATE criteria date format specifications (frontier)
- DATE criteria field types and formats (frontier)
- DATE vs CUSTOM criteria selection (frontier)
- Online Archive query performance optimization (frontier)
- Partition fields constraints for DATE rules (frontier)
- expireAfterDays data age calculation (frontier)
- CUSTOM Criteria (frontier)
- Archive Schedule Window (frontier)
- Archive Data Expiration Rule (frontier)
- Index Sufficiency Warning (frontier)
- Time Series Archive Rules (frontier)
- Online Archive Terraform Resource (frontier)
- Partition Fields (frontier)
- Federated Query on Archive (frontier)
- Archive Cost Model (frontier)
- Archive Restore (frontier)
- Archive Monitoring (frontier)
- Archive Anti-Patterns (frontier)
MongoDB Atlas App Services ● 2
App Services Authentication Providers ●
- App Services Rules and Permissions (frontier)
- App Services Schema Validation (frontier)
- Atlas GraphQL API (EOL) (frontier)
- Atlas Data API (EOL) (frontier)
- Custom HTTPS Endpoints (EOL) (frontier)
- App Services Values and Secrets (frontier)
- App Services Deployment Model (frontier)
App Services Billing Model ●
- App Services Migration Paths (frontier)
MongoDB Atlas Search ● 1
$search Operators ●
- Atlas Search Architecture (frontier)
- Search Index Mapping (frontier)
- Custom Analyzers (frontier)
- Autocomplete (frontier)
- Faceted Search (frontier)
- Search Highlighting (frontier)
- Relevance Scoring (frontier)
- Atlas Search Nodes (frontier)
- Atlas Search Anti-Patterns (frontier)
MongoDB Atlas Charts ● 3
- Chart Types (frontier)
- Data Sources (frontier)
Aggregation Pipeline in Charts ●
- Dashboards (frontier)
- Embedded Charts (frontier)
- Embedding SDK (frontier)
- Charts REST API (frontier)
Access Control ●
Anti-Patterns ●
- Cost Model (frontier)
- Quick Reference (frontier)
MongoDB Atlas Stream Processing ● 4
$source Operators ●
$emit Operators ●
mongodb-kafka-connector ● 3
kafka-source-connector ●
- change-stream-resume-token (frontier)
- heartbeat-configuration (frontier)
- startup-mode-copy-existing (frontier)
kafka-sink-connector ●
- write-model-strategies (frontier)
- DLQ-error-handling (frontier)
- bulk-write-ordering (frontier)
CDC-patterns ●
- outbox-pattern (frontier)
- exactly-once-semantics (frontier)
- debezium-handlers (frontier)
- write-model-strategies (frontier)
- DLQ-error-handling (frontier)
- schema-registry-integration (frontier)
- MSK-Connect-deployment (frontier)
- Stream Processing Instance (SPI) (frontier)
- Stream Processor Pipeline (frontier)
- Tumbling Windows (frontier)
- Hopping Windows (frontier)
- Session Windows (frontier)
- Watermarks and Late-Event Tolerance (frontier)
- Connection Registry (frontier)
- Dead Letter Queue (DLQ) (frontier)
- Stream Processor Monitoring (frontier)
ASP Pricing Model ●
MongoDB Atlas IAM and RBAC ● 2
- Atlas Three-Tier Identity Model (frontier)
- Atlas Organization Roles (frontier)
- Atlas Project Roles (15 Purpose-Built) (frontier)
- Atlas Database Users (frontier)
- Atlas Custom Database Roles (frontier)
- Atlas Programmatic API Keys (Legacy) (frontier)
- Atlas AWS IAM Database Auth (frontier)
- Atlas X.509 Certificate Auth (frontier)
- Atlas LDAPS (Deprecated 8.0) (frontier)
- Atlas SCRAM-SHA-256 (frontier)
- Atlas Database Auditing (frontier)
- Atlas Activity Feed (frontier)
- Atlas Log Push SIEM (frontier)
- Atlas IdP Group to Role Mapping (frontier)
- Atlas Organization Teams (frontier)
- Atlas Auth Tier Feature Matrix M0 Flex M10 (frontier)
- Atlas IAM Compliance Mapping (frontier)
Atlas Identity Federation and Resource Policy Boundaries 2
Current service-account OAuth, human/application federation and Cedar governance boundaries. Existing Cedar concept pack is preserved separately.
AWS IAM Outbound Identity Federation to Atlas ●
- Atlas IP access list for service accounts (frontier)
- Atlas WIF built-in vs callback authentication (frontier)
- Atlas federated database users and groups (frontier)
- Atlas org mapping and domain mapping (frontier)
- Entra ID group overage in Atlas (frontier)
- Federated database user mapping by sub/groups claim (frontier)
- Service account secret rotation (frontier)
- Terraform mongodbatlas_service_account without initial secret (frontier)
Atlas Resource Policies Cedar ●
Current service-account OAuth, human/application federation and Cedar governance boundaries. Existing Cedar concept pack is preserved separately.
- Atlas nonCompliantResources endpoint (frontier)
- Cedar forbid-only policy patterns for Atlas (frontier)
- Atlas Terraform mongodbatlas_resource_policy (frontier)
- Atlas Service Accounts OAuth 2.0 (frontier)
- Atlas Workforce Identity Federation (frontier)
- Atlas Workload Identity Federation (frontier)
MongoDB Atlas Infrastructure as Code ● 5
- Terraform Atlas Provider v2.x (frontier)
- Atlas Kubernetes Operator AKO v2.14 (frontier)
- Atlas CLI Scripting (frontier)
- Atlas Admin API v2 REST (frontier)
- Pulumi mongodbatlas Provider (frontier)
AWS CloudFormation Atlas Resources ●
AWS CDK awscdk-resources-mongodbatlas ●
- Service Account OAuth 2.0 Authentication (frontier)
- Programmatic API Keys Legacy Auth (frontier)
- mongodbatlas_advanced_cluster Resource (frontier)
- moved Block Migration Pattern (frontier)
- Terraform Drift Detection (frontier)
AKO Independent CRDs ●
AKO Subobject CRDs Deprecated ●
- AKO Dry Run Mode (frontier)
- AKO Deletion Protection v2.0 (frontier)
AKO Reconciliation Skip Annotation ●
- Atlas CLI Terraform Plugin (frontier)
- atlas kubernetes config generate (frontier)
- Multi-Environment Terraform Directories vs Workspaces (frontier)
- Service Account per Environment Pattern (frontier)
- Backup Compliance Policy One-Way (frontier)
- Atlas IP Access List Ownership Conflict (frontier)
- Terraform Import generate-config-out (frontier)
- Workload Identity Federation Atlas (frontier)
- Atlas Admin API Date Versioned Media Types (frontier)
- CloudFormation Third Party Activation (frontier)
- Atlas IaC Migration Paths (frontier)
- Atlas IaC Anti-Patterns (frontier)
- Atlas IaC Tool Decision Matrix (frontier)
Atlas Kubernetes Operator ● 6
AKO CRDs ●
AKO GitOps ●
AKO Workload Identity ●
AKO Helm Installation ●
AKO Troubleshooting ●
AKO vs Terraform ●
MongoDB Atlas Terraform Provider ●
- Atlas Cluster IaC (frontier)
- Atlas Networking IaC (frontier)
- Atlas RBAC IaC (frontier)
- Atlas Encryption IaC (frontier)
- Atlas Backup IaC (frontier)
- Terraform Provider v2 Migration (frontier)
MongoDB Atlas Device SDK ●
- Realm Object Model (frontier)
- Atlas Device Sync (frontier)
- Flexible Sync Subscriptions (frontier)
- Atlas Edge Server (frontier)
- Asymmetric Sync (frontier)
- Client Reset Strategies (frontier)
- Realm Authentication (frontier)
- Flutter Dart Realm SDK (frontier)
- Offline-First Mobile (frontier)
- Realm Migration (frontier)
MongoDB Atlas Analytics Node 5
Analytics Node Configuration ●
Analytics Node Read Preference Routing ●
Analytics Node Sizing ●
Analytics Node Monitoring ●
Analytics Node Cost Model ●
Atlas Service Accounts
- OAuth2 Token Exchange (frontier)
- Secret Rotation (frontier)
- Service Account Roles (frontier)
- Terraform Integration (frontier)
- Atlas CLI Integration (frontier)
Atlas Federated Authentication ●
- SAML 2.0 SSO flow (frontier)
- Federation Management Console (frontier)
- Connected organizations (frontier)
- Domain verification (frontier)
- Group-to-role mapping (frontier)
- JIT user provisioning (frontier)
- SCIM provisioning (frontier)
- Bypass SAML mode (frontier)
- IdP configuration (Okta) (frontier)
- IdP configuration (Entra ID) (frontier)
MongoDB Atlas AWS Networking ● 4
- VPC Peering (frontier)
AWS PrivateLink ●
- Network Access Lists (frontier)
- DNS and SRV Records (frontier)
- Multi-Region Networking (frontier)
- Transit Gateway Patterns (frontier)
- TLS Encryption (frontier)
- Security Groups (frontier)
- Connection Troubleshooting (frontier)
AWS CloudFormation Atlas ●
- Terraform Atlas Provider (frontier)
- EventBridge Integration (frontier)
- Lambda Integration (frontier)
- KMS Encryption at Rest (frontier)
- IAM Authentication (frontier)
AWS ISV Accelerate ●
AWS Marketplace Atlas ●
- EDP Credits (frontier)
MongoDB Backup and Restore 1
- Atlas Cloud Backup (snapshots) (frontier)
- Continuous Cloud Backup (PITR) (frontier)
- Queryable Backups (frontier)
- Ops Manager Backup (frontier)
- Restore Workflows (frontier)
Backup Compliance Policy (WORM) ●
- Cross-Region Snapshot Copy (frontier)
- Backup Verification and Tabletop Exercises (frontier)
- Backup Anti-Patterns (frontier)
MongoDB Atlas Cost Optimization ● 1
- Instance Right-Sizing (frontier)
- Storage Tier Selection (frontier)
- Elastic Compute Autoscaling (frontier)
- Storage Autoscaling (frontier)
- Backup Cost Optimization (frontier)
- Network Egress Costs (frontier)
- Reserved Capacity and Committed Use (frontier)
- Cluster Pause (frontier)
- Index Storage Cost (frontier)
- Cost Monitoring (frontier)
- Tier 0 Tier 1 Tier 2 Strategy (frontier)
- Common Cost Overruns (frontier)
MongoDB Atlas Flex and Serverless Tiers ●
- Atlas Flex Pricing Model (frontier)
- Atlas Flex Technical Limits (frontier)
- Serverless RPU WPU Billing (frontier)
- Serverless Cold Start Behavior (frontier)
- Serverless Deprecation and EOL (frontier)
- M2 M5 Migration to Flex (frontier)
- Flex vs Dedicated Decision Matrix (frontier)
- Flex Tooling Migration Terraform K8s CLI (frontier)
- M0 Free Tier vs Flex Comparison (frontier)
- Atlas Flex Unsupported Features (frontier)
- Flex Cost Break-Even Analysis (frontier)
MongoDB Atlas Multi-Cloud ●
- Atlas on Azure (frontier)
- Azure Private Link for Atlas (frontier)
- Atlas on GCP (frontier)
- GCP Private Service Connect for Atlas (frontier)
- Multi-Cloud Replica Sets (frontier)
- Multi-Cloud Global Clusters (frontier)
- Multi-Cloud Billing (frontier)
- Azure Partnership and MACC (frontier)
- GCP Partnership and Marketplace (frontier)
- Multi-Cloud DR Pattern (frontier)
- Cross-Cloud Egress Costs (frontier)
- Multi-Cloud Failure Modes (frontier)
MongoDB Realm Mobile Sync ● 1
- Atlas Device Sync Overview (frontier)
- Realm SDK Languages and Platforms (frontier)
- Flexible Sync (frontier)
- Partition-Based Sync (Legacy) (frontier)
- Conflict Resolution (frontier)
- Realm Object Model (frontier)
- Sync Configuration (frontier)
- Permissions Model (frontier)
- Offline-First Patterns (frontier)
App Services Context ●
- Common Pitfalls (frontier)
MongoDB Atlas Triggers and Functions 1
- Database Triggers (frontier)
- Scheduled Triggers (frontier)
- Authentication Triggers (frontier)
- Atlas Functions JavaScript Runtime (frontier)
- Function Context Object (frontier)
- HTTPS Endpoints (frontier)
- Trigger Error Handling and Suspension (frontier)
App Services CLI Deployment ●
- Realm Migration Paths (frontier)
- Atlas App Services Cost Model (frontier)
- Change Data Capture Patterns (frontier)
- Trigger and Function Anti-Patterns (frontier)
MongoDB Atlas Search and Vector Search ● 1
- Atlas Search Lucene Architecture (frontier)
- Atlas Vector Search HNSW IVF (frontier)
- RAG Patterns with Vector Search (frontier)
- Atlas Search Analyzers and Tokenizers (frontier)
- Stored Source Performance Optimization (frontier)
- Auto Embedding Voyage AI (frontier)
- Search Nodes Dedicated Infrastructure (frontier)
- Lexical Prefilters for Vector Search (frontier)
Atlas Hybrid Fusion and BM25 Diagnostics
Current scoped MongoDB frontier research. Rank/score fusion eligibility, normalization and BM25 explanations. Lexical prefilters and stored source remain unresolved.
- BM25 IDF corpus statistics (frontier)
- BM25 term frequency saturation and field length normalization (frontier)
- Fusion score normalization strategies (frontier)
- Per-query fusion weighting (frontier)
- Ranked and scored input pipeline eligibility (frontier)
- Hybrid Search $rankFusion $scoreFusion (frontier)
- Score Details BM25 Diagnostics (frontier)
MongoDB BI Connector and SQL Access ● 2
Atlas SQL Interface MongoSQL ●
- MongoSQL ODBC Driver (frontier)
- Atlas SQL Schema Builder (frontier)
- Power BI DirectQuery (frontier)
- Tableau Certified Connector (frontier)
- BI Connector to MongoSQL Migration (frontier)
Atlas Data API Removal ● 5
Express MongoDB Driver Pattern
FastAPI Motor Pattern
Lambda MongoDB Driver Pattern
Delbridge Data API
RESTHeart
- Atlas GraphQL API Removal (frontier)
- mongosqld Architecture (frontier)
- DRDL Schema Management (frontier)
- BI Connector Authentication (frontier)
- SQL-to-MQL Translation (frontier)
- BI Connector EOL Migration (frontier)
- HTTP Data Access Replacements (frontier)
- Atlas GraphQL API Removal (frontier)
MongoDB Atlas on Azure ● 2
- Azure Private Link for Atlas (frontier)
- Atlas Private DNS Zones Azure (frontier)
- NSG Rules for Atlas (frontier)
- Hub-and-Spoke Atlas Networking (frontier)
- Azure Private DNS Resolver (frontier)
- ExpressRoute Atlas Connectivity (frontier)
- Entra ID OIDC Workforce Federation (frontier)
- Entra ID Workload Identity Federation (frontier)
AKS Workload Identity Atlas ●
- Atlas LDAP Azure AD DS (frontier)
- Atlas SAML Entra ID (frontier)
- Azure Key Vault Atlas BYOK (frontier)
- Atlas Secretless KV Authentication (frontier)
- Azure Key Vault RBAC Atlas (frontier)
- Atlas Key Rotation AKV (frontier)
- KMS Failsafe Behavior Atlas (frontier)
AKS Atlas Kubernetes Operator ●
- Azure Functions Atlas Connection Pooling (frontier)
- Azure Event Hub Atlas Stream Processing (frontier)
- Azure Service Bus Atlas Triggers (frontier)
- Azure App Service Atlas (frontier)
- Azure Container Apps Atlas (frontier)
- Azure Synapse Atlas Data Federation (frontier)
- Azure OpenAI Atlas Vector Search (frontier)
- Atlas MACC Eligibility (frontier)
- Azure Native MongoDB ANM (frontier)
- Azure Marketplace Atlas Billing (frontier)
- Atlas Sentinel Log Integration (frontier)
- Atlas Azure Monitor Metrics (frontier)
- Atlas Application Insights OTel (frontier)
- Atlas Azure Regions Mapping (frontier)
- AtlasGov Azure Government (frontier)
- Atlas Terraform Azure Provider (frontier)
- Atlas Bicep Private Endpoint (frontier)
- Atlas Azure Troubleshooting Playbook (frontier)
- Atlas Azure Security Compliance (frontier)
MongoDB Atlas on GCP ● 1
Atlas Admin API GCP Auth ●
- GCP Private Service Connect (frontier)
- PSC Port-Mapped Architecture (frontier)
- PSC Legacy Migration (frontier)
- GCP VPC Peering (frontier)
- GCP Shared VPC (frontier)
- Cloud DNS Private Zone for Atlas (frontier)
- GCP Global Access PSC (frontier)
- Cloud NAT for Atlas (frontier)
- GCP Workload Identity Federation OIDC (frontier)
- Google Workspace SAML Federation (frontier)
- Google Cloud KMS BYOK (frontier)
- Atlas Envelope Encryption GCP (frontier)
- Cloud HSM Atlas (frontier)
- KMS Key Rotation Atlas (frontier)
- KMS Unavailability Failsafe (frontier)
- GKE Atlas Kubernetes Operator (frontier)
- Cloud Run Atlas Connection Pooling (frontier)
- Cloud Functions Gen2 Atlas (frontier)
- Vertex AI Atlas Vector Search (frontier)
- BigQuery Atlas Dataflow CDC (frontier)
- Atlas Data Federation GCS (frontier)
- Atlas Stream Processing Pub/Sub (frontier)
- Looker Atlas BI Connector (frontier)
- Cloud Monitoring Atlas Metrics (frontier)
- Atlas Audit Logs Cloud Logging (frontier)
- Atlas Alerts Pub/Sub Escalation (frontier)
- GCP Marketplace Atlas Billing (frontier)
- Atlas GCP EDP Credits (frontier)
- GCP Regions Atlas Mapping (frontier)
- Atlas Terraform GCP Provider (frontier)
- PSC Terraform GCP (frontier)
- Cloud DNS Terraform Atlas (frontier)
- Atlas GCP Troubleshooting (frontier)
- GCP Forwarding Rule Quota (frontier)
- GKE NodeLocal DNSCache Atlas (frontier)
- Cloud Build Atlas API Auth (frontier)
- Google Distributed Cloud GDC (frontier)
- Google Cloud Partner of Year (frontier)
- MongoDB for Startups GCP (frontier)
MongoDB Atlas Vector Search ●
- HNSW Index Parameters (frontier)
- Vector Quantization (frontier)
- Hybrid Search (frontier)
- Voyage AI Embeddings (frontier)
- RAG Patterns (frontier)
- Search Nodes (frontier)
- Embedding Pipelines (frontier)
- Multi-Vector Patterns (frontier)
MongoDB Atlas Data Federation
- MongoDB Atlas Data Federation Architecture Internals (frontier)
- MongoDB Atlas Data Federation Benchmark Metrics (frontier)
- MongoDB Atlas Data Federation Operational Runbook (frontier)
- MongoDB Atlas Data Federation Failure Scenarios (frontier)
MongoDB Performance Troubleshooting 2
WiredTiger Storage Engine Internals ● 4
- Cache Architecture (frontier)
Eviction (clean/dirty targets and triggers) ●
- Application Thread Eviction (frontier)
- Reconciliation and Page Splitting (frontier)
Checkpoint Mechanism ●
- Journal (Write-Ahead Log) (frontier)
- MVCC and Snapshot Isolation (frontier)
History Store (WiredTigerHS.wt) ●
- Timestamp APIs (oldest/stable/pinned) (frontier)
- Block Compression (snappy/zlib/zstd) (frontier)
- Prefix Compression (indexes) (frontier)
- Block Manager and Page Sizing (frontier)
Read/Write Tickets and Dynamic Concurrency (7.0+) ●
- In-Memory Storage Engine (Enterprise) (frontier)
- Encryption at Rest (KMIP, AES-256-CBC/GCM) (frontier)
- Diagnostic Surface (serverStatus, FTDC, verbose components) (frontier)
- wiredTigerEngineRuntimeConfig (frontier)
- WT_CACHE_FULL / Cache Pressure Troubleshooting (frontier)
- Corruption (validate, --repair, wt CLI) (frontier)
- Long-Running Transactions and Cache Pressure (frontier)
- MongoDB 8.0 WT Improvements (TCMalloc, ExpressPlan) (frontier)
- Query Planning and Plan Cache (frontier)
- Index Analysis (frontier)
FTDC Diagnostics ●
- Explain Plan Interpretation (frontier)
- Performance Diagnostic Workflow (frontier)
MongoDB Developer Patterns ● 6
MongoDB Drivers
- MongoDB Drivers Architecture Internals (frontier)
- MongoDB Drivers Benchmark Metrics (frontier)
- MongoDB Drivers Operational Runbook (frontier)
- MongoDB Drivers Failure Scenarios (frontier)
mongosh Reference
- mongosh Reference Architecture Internals (frontier)
- mongosh Reference Benchmark Metrics (frontier)
- mongosh Reference Operational Runbook (frontier)
- mongosh Reference Failure Scenarios (frontier)
Atlas CLI
- Atlas CLI Architecture Internals (frontier)
- Atlas CLI Benchmark Metrics (frontier)
- Atlas CLI Operational Runbook (frontier)
- Atlas CLI Failure Scenarios (frontier)
Error Codes and Troubleshooting
- Error Codes and Troubleshooting Architecture Internals (frontier)
- Error Codes and Troubleshooting Benchmark Metrics (frontier)
- Error Codes and Troubleshooting Operational Runbook (frontier)
- Error Codes and Troubleshooting Failure Scenarios (frontier)
- Customer Troubleshooting Playbooks (frontier)
MongoDB Driver Internals 5
CMAP Connection Pooling ●
SDAM Topology State Machine ●
- Server Selection Algorithm (frontier)
Retryable Writes ●
- Retryable Reads (frontier)
- Read and Write Concerns (frontier)
Causal Consistency ●
- client sessions (frontier)
- afterClusterTime (frontier)
- operationTime (frontier)
- clusterTime (frontier)
- read your own writes (frontier)
- monotonic reads (frontier)
- implicit vs explicit sessions (frontier)
- cross-service causal tokens (frontier)
- Sessions (frontier)
- Multi-document Transactions (frontier)
Client Side Operations Timeout (CSOT) ● 1
- Adaptive Timeouts in Database Drivers (frontier)
- Client Side Field Level Encryption (CSFLE) (frontier)
- Deadline Propagation and Context Cancellation in MongoDB Drivers (frontier)
- Quantile Estimation (DDSketch) (frontier)
- Request Hedging (frontier)
- Server Selection Timeout (frontier)
- Tail Latency Mitigation (frontier)
- maxTimeMS (Server-side Operation Timeout) (frontier)
- DNS SRV Discovery (frontier)
- TLS and OCSP (frontier)
- client-side-operations-timeout-csot (frontier)
MongoDB Spark Connector and Databricks Integration
- Spark Connector V10 Architecture (frontier)
- Batch Reads and Aggregation Pushdown (frontier)
- Partitioner Strategies (frontier)
- Schema Inference and Type Promotion (frontier)
- Batch Writes and Idempotency (frontier)
- Structured Streaming with Change Streams (frontier)
- Streaming Write Semantics (frontier)
- Databricks Workspace Integration (frontier)
- Spark Connector vs Alternatives (frontier)
- Connector Error Patterns (frontier)
- Performance Tuning Checklist (frontier)
MongoDB KB Articles ●
- Error Code Lookup (frontier)
- Connectivity Troubleshooting (frontier)
- Replica Set Support Articles (frontier)
- Performance KB Articles (frontier)
- Security KB Articles (frontier)
MongoDB Security Architecture ●
- Authentication Methods (frontier)
- Atlas RBAC (frontier)
- Network Security Layers (frontier)
- Atlas Audit Logging (frontier)
- Self-Managed Security Config (frontier)
- Org and Project Governance (frontier)
- Encryption in Transit (frontier)
- Secrets Management (frontier)
- Atlas Security Posture Checklist (frontier)
MongoDB Performance Benchmarking 1
MongoDB Performance Regression Detection and Testing Methodology
- Change Point Detection (frontier)
- Coefficient of Variation / Run-to-Run Noise Control (frontier)
- CI Performance Regression Gating (frontier)
- Canary and Shadow-Traffic Comparison (frontier)
- MongoDB Major-Version Upgrade Regression Detection (frontier)
- YCSB Workload Reference (frontier)
- Workload Characterization (frontier)
- Atlas Performance Advisor (frontier)
- Connection Pool Benchmarking (frontier)
- Index Effectiveness Measurement (frontier)
- Baseline Methodology (frontier)
- Atlas Tier Selection (frontier)
- Benchmarking Anti-Patterns (frontier)
- Benchmark Result Reporting (frontier)
MongoDB Multi-Tenancy ●
- Tenant Isolation Models (frontier)
- Shard Key Design for Multi-Tenancy (frontier)
- RBAC and Connection Security (frontier)
- Connection Pooling Strategies (frontier)
- Schema Design for Multi-Tenancy (frontier)
- Atlas Projects as Hard Isolation (frontier)
- Billing and Cost Chargeback (frontier)
- Tenant Lifecycle Operations (frontier)
- Row-Level Security Patterns (frontier)
- Multi-Tenancy Anti-Patterns (frontier)
MongoDB Connection String URI
- Standard URI Format (frontier)
- SRV DNS Seedlist Format (frontier)
- Authentication Mechanisms (frontier)
- TLS/SSL Configuration (frontier)
- Connection Pool Tuning (frontier)
- Read Preference (frontier)
- Write Concern (frontier)
- Read Concern (frontier)
- Wire Protocol Compression (frontier)
- CSOT Client-Side Operations Timeout (frontier)
Atlas Diagnostics Expert ● 4
FTDC and Log Tooling
- FTDC Chunk Decompression & Stream Parsing (frontier)
- WiredTiger Ticket Metric Telemetry in FTDC (frontier)
- mtools Log Analysis Integration (frontier)
- FTDC Storage Overhead & Retention Budgeting (frontier)
KB-Backed Troubleshooting
- SERVER JIRA Ticket Regression Mapping (frontier)
- Error Code Hierarchy & Assertion Types (frontier)
- Crash Stack Trace Symbolization (frontier)
- Customer Hotfix & Patch Verification (frontier)
Diagnostic Tool Design
- Lock-Free Diagnostic Sampling Engine (frontier)
- Streaming BSON Parser Architecture (frontier)
- PII Masking & Query Hash Anonymization (frontier)
- Telemetry Overhead Bounding Algorithms (frontier)
Atlas Triage Workflows
- Atlas Performance Advisor Auto-Index Evaluation (frontier)
- Disk IOPS Burst Credit Depletion Playbook (frontier)
- Network Connection Quota Management (frontier)
- Automated Cluster Scaling Decision Matrix (frontier)
MongoDB Upgrade Paths ● 3
- Version upgrade paths (4.4 → 5.0 → 6.0 → 7.0 → 8.0) (frontier)
- Straight-to-8 jump pattern (frontier)
Feature Compatibility Version (FCV) ●
- FCV pinning and downgrade preservation window (frontier)
- Point of No Return (frontier)
- Rolling replica-set upgrade (frontier)
Replica-set election timing ●
- Arbiter handling and PSA topology (frontier)
Sharded cluster upgrade ordering ●
- Config server / shards / mongos upgrade sequence (frontier)
- mongos version skew rules (frontier)
- Config shard caveat (8.0+) (frontier)
- Driver compatibility matrix (Java/Node/Python/.NET/Go) (frontier)
- Java driver 4.10 and 5.x retry semantics (frontier)
- Pre-upgrade safety checks (frontier)
- In-flight index builds (frontier)
- Change-stream resumability (frontier)
- Oplog window sizing (frontier)
- Index build commit quorum (8.0 nuance) (frontier)
- Upgrade rollback playbook (frontier)
- Binary downgrade window (frontier)
- Disk pre-warming SOP (Cookie 7.0→8.0 lesson) (frontier)
- WiredTiger cache warm-up (frontier)
- Upgrade event coverage (pre/during/post) (frontier)
- Error Envelope and customer sign-off (frontier)
- Common upgrade failures (frontier)
- Driver mismatch failure mode (frontier)
- FCV unpinned too early (frontier)
- Index build conflicts (frontier)
- mongos version skew failure (frontier)
- PSA topology stepdown failure (frontier)
- Oplog window overflow (frontier)
- Cold-cache latency regression (frontier)
MongoDB Aggregation Pipeline ● 5
$merge and $out Materialized Views ●
mongodb-aggregation-stages-deep ● 7
$lookup ●
$graphLookup ●
$facet ●
$bucket-bucketAuto ●
$setWindowFields ●
$densify-$fill ●
$unionWith ●
- allowDiskUse-100MB-stage (frontier)
- explain-executionStats-usedDisk (frontier)
- Pipeline Stages Reference (frontier)
- Pipeline Optimization (frontier)
Aggregation Expressions ●
- Window Functions ($setWindowFields) (frontier)
- Time Series Aggregation (frontier)
- Memory Limits and allowDiskUse (frontier)
- Driver Examples (Node.js, Python, Java) (frontier)
mongodb-time-series ● 2
$dateTrunc Downsampling ●
$setWindowFields Window Functions ●
- Time Series Collection Creation (timeField, metaField, granularity) (frontier)
- Bucket Architecture and Columnar Compression (frontier)
- Secondary Indexes on Time Series (frontier)
- TTL and Automatic Bucket Deletion (frontier)
- Atlas Charts Integration (frontier)
- Atlas Triggers Workarounds (no change streams) (frontier)
- Time Series Sharding Patterns (frontier)
- Working Set Sizing for Time Series (frontier)
- Migration from Regular Collections (frontier)
- Granularity Anti-Patterns (frontier)
- metaField Cardinality Anti-Patterns (frontier)
- MongoDB 8.0 Block Processing (frontier)
MongoDB Migration Patterns ●
- MongoSync GA Tool (frontier)
- Cluster-to-Cluster Sync Phases (frontier)
- Relational Migrator (frontier)
- Atlas Live Migration (frontier)
- mongomirror Deprecation (frontier)
- Cutover Strategies (frontier)
- Migration Validation Patterns (frontier)
- Schema Transformation (frontier)
- Sharded Cluster Migrations (frontier)
- Common Migration Failures (frontier)
MongoDB Indexes Deep Dive ●
- Single-Field Indexes (frontier)
- Compound Indexes and ESR Rule (frontier)
- Multikey Indexes (frontier)
- Partial Indexes (frontier)
- Sparse Indexes (frontier)
- TTL Indexes (frontier)
- Text Indexes (frontier)
- Wildcard Indexes (frontier)
- Hashed Indexes (frontier)
- Unique Indexes (frontier)
- Index Intersection (frontier)
- Index Build Strategies (frontier)
- Index Selectivity and Covering Queries (frontier)
- Hidden Indexes (frontier)
- hint() and Index Forcing (frontier)
- Index Anti-Patterns (frontier)
MongoDB Geospatial ● 6
2dsphere Indexes ●
2d Indexes ●
$geoNear Aggregation Stage ●
$geoWithin and $centerSphere ●
$geoIntersects ●
$near and $nearSphere ●
- GeoJSON Object Types (frontier)
- Radius Unit Conversions (frontier)
- Geospatial $lookup Patterns (frontier)
- Geospatial Anti-Patterns (frontier)
MongoDB Compliance and Regulatory ●
- Atlas Compliance Certifications (frontier)
- FedRAMP and AtlasGov (frontier)
- HIPAA BAA and ePHI Configuration (frontier)
- PCI DSS Scoping and Tokenization (frontier)
- Data Residency and EU Sovereignty (frontier)
- Atlas Audit Logging (frontier)
- Encryption Requirements (At-Rest, In-Transit, Field-Level) (frontier)
- BYOK Key Management (frontier)
- Atlas Access Control and RBAC (frontier)
- Compliance Gaps and Shared Responsibility (frontier)
- Audit-Ready Architecture and Evidence Collection (frontier)
- Common Audit Findings and Remediation (frontier)
MongoDB Transactions ● 8
Multi-Document Transactions
Replica Set Transactions
Distributed Sharded Transactions
- Read Concern (frontier)
- Write Concern (frontier)
Transaction Limits
Retryable Transactions
Driver Examples
Performance Impact
Transaction Anti-Patterns
MongoDB Capacity Planning ●
- Working Set Sizing (frontier)
- IOPS Forecasting (frontier)
- Storage Growth Modeling (frontier)
- Connection Capacity (frontier)
- Oplog Sizing (frontier)
- Cluster Tier Selection (frontier)
- Sharding Triggers (frontier)
- Read vs Write Distribution (frontier)
- Atlas Performance Advisor (frontier)
- Growth Signals (frontier)
- Capacity Testing (frontier)
- Common Sizing Mistakes (frontier)
MongoDB Compass ●
- Compass Editions (frontier)
- Compass Connection Management (frontier)
- Compass Schema Analysis (frontier)
- Compass Aggregation Pipeline Builder (frontier)
- Compass Explain Plan Visualizer (frontier)
- Compass Index Management (frontier)
- Compass Performance Insights (frontier)
- Compass CRUD and Documents Tab (frontier)
- Compass Natural Language Query (frontier)
- Compass Data Import Export (frontier)
- Compass Plugins and Extensibility (frontier)
- Compass Data Modeling ER Diagrams (frontier)
- Compass Anti-Patterns (frontier)
- Compass Real-Time Performance Monitoring (frontier)
MongoDB University & Certification ●
- MongoDB University Platform (frontier)
- Associate Developer Certification (frontier)
- Associate DBA Certification (frontier)
- Associate Atlas Administrator (frontier)
- Associate Data Modeler (frontier)
- Skill Badges (free micro-credentials) (frontier)
- Learning Paths by Role (frontier)
- Instructor-Led Training (frontier)
- Credly Digital Badges (frontier)
- TAM Positioning Playbook (frontier)
Atlas cluster tiers (M30) & major-version upgrade mechanics
- M30 specs & connection limits (frontier)
- rolling upgrade & elections (frontier)
- FCV pinning no-downgrade rule (frontier)
- Atlas Gen2 ARM hardware (frontier)
MongoDB 8.0 performance changes & read-path regressions vs 7.0 1
8.0.x regression catalog ●
- express execution path (frontier)
- SBE vs classic engine defaults (frontier)
- TCMalloc per-CPU caches (frontier)
- majority-ack write concern change (frontier)
MongoDB Java driver 5.x version timeline & 8.0 compatibility 2
5.6.x RawBsonDocument codec regression ●
5.7/5.8 release notes ●
- minor-version compatibility rule (frontier)
MongoDB Monitoring and Observability ● 2
Atlas Maintenance Windows ●
- Maintenance Window Configuration (frontier)
- Rolling Maintenance Procedure (frontier)
- Deferring Maintenance (frontier)
- Emergency Security Patches (frontier)
- Maintenance Impact Minimization (frontier)
- Sharded Cluster Maintenance (frontier)
- Atlas Metrics and Dashboards (frontier)
- Atlas Alerts (frontier)
- Datadog Integration (frontier)
- Prometheus Integration (frontier)
- New Relic Integration (frontier)
- Slow Query Monitoring (frontier)
- Replication Lag Monitoring (frontier)
- Connection Metrics (frontier)
MongoDB Replication ● 2
Read Concern Levels ●
- local read concern (frontier)
- available read concern (frontier)
- majority read concern (frontier)
- linearizable read concern (frontier)
- snapshot read concern (frontier)
- majority commit point mechanics (frontier)
- read concern in sharding (frontier)
MongoDB Stress, Soak, and Chaos-Resilience Testing
- Sustained overload / soak testing (memory leaks, connection pool exhaustion, WiredTiger cache thrashing, ticket starvation, oplog window shrinkage) (frontier)
- Breaking-point / overload testing methodology (first bottleneck vs visible symptom, cascading failure, thundering herd, cache-eviction death spiral) (frontier)
- Chaos-style resilience testing under load (kill primary during peak writes, network partition, disk-full/IO-stall injection) (frontier)
- Safe execution against non-production Atlas (cluster isolation, guardrails, cost/cleanup discipline) (frontier)
MongoDB autoCompact 8
autoCompact freeSpaceTargetMB Gating
autoCompact runOnce vs Continuous Mode
WiredTiger Compaction Algorithm 1
Background-Compaction Skip/EMA Heuristic
autoCompact Checkpoint Interaction
autoCompact Cluster Topology Behavior
autoCompact Atlas-Specific Behavior
autoCompact Lifecycle and Persistence
autoCompact and Replica-Set Write Blocking
mongodb-schema-design 1
mongosync ●
- initial-sync-and-cdc (frontier)
- namespace-filtering (frontier)
- resume-and-checkpoint (frontier)
- verification-modes (frontier)
- reverse-sync-cutover (frontier)
- oplog-window-sizing (frontier)
- atlas-live-migration-comparison (frontier)
- mongosync-state-machine (frontier)
- loadlevel-tuning (frontier)
- tls-x509-auth (frontier)
MongoDB Ops Manager and Cloud Manager ● 1
- Ops Manager Application (frontier)
- Application Database (App DB) (frontier)
- Backup Daemon and Head DB (frontier)
- MongoDB Agent (Automation, Monitoring, Backup) (frontier)
- Goal-State Automation Configuration (frontier)
- Continuous Backup with PITR (frontier)
- Blockstore Snapshot Storage (frontier)
- S3-Compatible Snapshot Storage with Object Lock (frontier)
- Filesystem Snapshot Storage (frontier)
- Local Mode and Air-Gap Deployments (frontier)
- Version Manifest Mirroring (frontier)
- Ops Manager LDAP/Kerberos/SAML/OIDC Federation (frontier)
- Workforce and Workload Identity Federation (frontier)
- Kubernetes Operator Deployment (frontier)
- Cloud Manager Free/Standard/Premium Tiers (frontier)
- Live Migration to Atlas via mongosync (frontier)
- Migration Host Provisioning (frontier)
- Source Oplog Window Sizing for Migration (frontier)
- PagerDuty/Datadog/Splunk Integration (frontier)
- OpenTelemetry MongoDB Receiver (frontier)
- Enterprise Advanced Licensing (frontier)
- Ops Manager High Availability (frontier)
- Cross-DC App DB Placement (frontier)
- Backup Daemon HA and Failure Domains (frontier)
- Ops Manager Architecture (frontier)
- Automation Agent (frontier)
- Monitoring Agent (frontier)
- Backup Daemon (frontier)
- Blockstore and Snapshot Stores (frontier)
- Ops Manager Admin API (frontier)
- LDAP and Federation (frontier)
- Upgrade Procedures (frontier)
- Common Failure Modes (frontier)
- Multi-Org Scale Patterns (frontier)
Air-Gap and Local Mode ●
- Live Migration to Atlas (frontier)
Personal Life & Property 2
Buying used cars at auction and North Carolina real-estate rules.
Used Car Auctions and Buying 11
Reference hub for buying a used car through salvage/insurance auctions (Copart, IAAI) or through the cheaper alternatives to them. Compiled from source-cited `/rabbithole` research (SEC filings, regulatory records,…
Copart Salvage Auctions ●
IAAI Salvage Auctions ●
AutoBidMaster International Bidding ●
Reading a Salvage Auction Listing ●
Salvage Auction Bidding Strategy ●
Individual Buyer Best Practices at Salvage Auctions ●
Salvage and Clean-Title Vehicle Valuation ●
Auction Vehicle Repair Cost Estimation ●
Newbie Mistakes in Used Car Buying ●
Best-Value Used Car Selection ●
Low-Cost Alternative Car-Buying Channels ●
North Carolina real estate agency licensing and commission rules 7
NCREC licensing provisional broker broker BIC
NC agency relationships and WWREA disclosure
NC buyer-agency agreements and NAR settlement compensation
NC Offer to Purchase and Contract Form 2-T
NC closing deeds and title
NC Residential Property Disclosure Act (G.S. Chapter 47E)
- Residential Property and Owners' Association Disclosure Statement (RPOADS, REC 4.22) (frontier)
- Mineral and Oil and Gas Rights Mandatory Disclosure Statement (MOG, REC 4.25) (frontier)
- No Representation answer mechanism (Yes/No/No Representation) (frontier)
- Section 47E-2 exemptions (full 47E-2(a) vs partial 47E-2(b)) (frontier)
- Section 47E-5 buyer 3-day cancellation right (frontier)
- Broker independent material-fact duty (21 NCAC 58A .0114) (frontier)
NC Coastal and Flood Real Estate (CAMA, flood disclosure, coastal insurance)
- Coastal Area Management Act (CAMA, G.S. 113A) and the 20 coastal counties (frontier)
- Areas of Environmental Concern (AECs) and the Ocean Hazard system (frontier)
- CAMA major/minor/general permits (frontier)
- Oceanfront construction setbacks and erosion rates (frontier)
- Permanent-hardened-structure ban, sandbags, and post-storm rebuilding (frontier)
- FEMA flood zones, SFHA, FIRM, and the NC FRIS lookup (frontier)
- Flood disclosure via RPOADS Section F (F5-F10, REC 4.22 REV 5/24) (frontier)
- Federal mandatory-purchase requirement and Risk Rating 2.0 (frontier)
- NC Coastal Property Insurance Pool (Beach Plan/NCIUA), wind vs flood (frontier)
- Coastal insurance rate filings, non-renewals, and CBRA/CBRS zones (frontier)
Sciences & Human Behavior 2
Psychology and the natural sciences.
Human Psychology 1
Applied Human Psychology ● 13
Behavior-Change Psychology for Customer Adoption
- Self-Determination Theory (autonomy, competence, relatedness) (frontier)
- Intrinsic vs extrinsic motivation continuum (Organismic Integration Theory) (frontier)
- Overjustification effect (frontier)
- Fogg Behavior Model (B=MAP) (frontier)
- Tiny Habits method (frontier)
- Transtheoretical Model / Stages of Change (frontier)
- Decisional balance and self-efficacy (frontier)
- Habit loop (cue-routine-reward) (frontier)
- Implementation intentions (Gollwitzer) (frontier)
- Habit stacking (frontier)
- Goal-setting theory (Locke & Latham five principles) (frontier)
- SMART goals (frontier)
- Goal-gradient and endowed progress effect (frontier)
- Goals Gone Wild (goal-setting dark side) (frontier)
- COM-B / Behavior Change Wheel (adjacent) (frontier)
Behavioral Decision-Making and Cognitive Biases ●
- Dual-Process Theory (System 1 / System 2) (frontier)
- Heuristics and Biases (anchoring, availability, representativeness, confirmation, hindsight, overconfidence, status-quo, sunk-cost) (frontier)
- Prospect Theory (loss aversion, reference dependence, probability weighting, fourfold pattern, framing) (frontier)
- Bounded Rationality and Satisficing (Simon) (frontier)
- Ecological Rationality and Fast-and-Frugal Heuristics (Gigerenzer) (frontier)
- Mental Accounting and Present Bias / Hyperbolic Discounting (frontier)
- Choice Architecture, Nudges, and Boosts (defaults, EAST, MINDSPACE, sludge, Hertwig boosts) (frontier)
- Debiasing Techniques (consider-the-opposite, premortem, reference-class forecasting, checklists) (frontier)
- Replication Status of Decision and Social-Psych Effects (power posing, social priming, ego depletion, loss-aversion debate) (frontier)
- Naturalistic Decision Making / Recognition-Primed Decision (Klein) (frontier)
- Neuroeconomics & Reward (dopamine prediction error, neural valuation) (frontier)
Trust, Rapport & Psychological Safety ●
- Interpersonal Trust Models (ABI / cognitive-affective / Trust Equation) (frontier)
- Swift Trust in Temporary Teams (frontier)
- Trust Violation & Repair (competence vs integrity) (frontier)
- Trust Asymmetry (slow-build / fast-break) (frontier)
- Rapport (similarity, mere-exposure, synchrony) (frontier)
- Active-Constructive Responding & Gottman Ratio (frontier)
- Psychological Safety (Edmondson) (frontier)
- Four Stages of Psychological Safety (Clark) (frontier)
- Psychological Safety vs Trust (frontier)
Persuasion & Influence Psychology (Attitude-Change Theory) ●
- Elaboration Likelihood Model (central vs peripheral route, elaboration, need for cognition) (frontier)
- Heuristic-Systematic Model (systematic vs heuristic, sufficiency threshold, additivity/bias) (frontier)
- Cognitive Dissonance (induced compliance, effort justification, free-choice paradigm, post-decision dissonance) (frontier)
- Self-Perception Theory (Bem) as the rival account + latitude reconciliation (frontier)
- Psychological Reactance (Brehm: freedom threat, boomerang effect, Rains 2013 effect size) (frontier)
- Attribution Theory (Heider, Kelley covariation, FAE, actor-observer asymmetry, self-serving bias) (frontier)
- Normative vs Informational Influence (Deutsch & Gerard) (frontier)
- Descriptive vs Injunctive Norms / Focus Theory of Normative Conduct (Cialdini) (frontier)
- Social Proof as informational influence under uncertainty (frontier)
- Asch Conformity & Milgram Obedience with modern caveats (Burger 2009) (frontier)
- Yale Attitude-Change Approach (source/message/channel/audience, sleeper effect) (frontier)
- Inoculation Theory (McGuire) and modern prebunking (frontier)
Emotion & Affect Psychology ●
- Appraisal Theory (Lazarus primary/secondary; Scherer Component Process Model) (frontier)
- Structure of Emotion (Basic/Ekman vs Dimensional-Circumplex/Russell vs Constructed/Barrett) (frontier)
- Emotion Regulation (Gross Process Model; Reappraisal vs Suppression; Troy controllability caveat) (frontier)
- Affect-as-Information (Schwarz & Clore; mood-congruent judgment; misattribution) (frontier)
- Affective Forecasting & Impact/Durability Bias (Gilbert & Wilson; focalism; immune neglect) (frontier)
- Emotional Contagion (Hatfield, Cacioppo & Rapson; mimicry-feedback-contagion) (frontier)
- Emotional Intelligence (Mayer-Salovey ability model + MSCEIT vs Goleman/Bar-On mixed) (frontier)
- Emotional Labor (Hochschild; surface vs deep acting) (frontier)
Performance, Motivation & Resilience Psychology ●
- Implicit Theories of Ability (Growth vs Fixed Mindset, Dweck) (frontier)
- Grit and the Conscientiousness Overlap (Duckworth, Credé) (frontier)
- Flow and Challenge-Skill Balance (Csikszentmihalyi) (frontier)
- Self-Efficacy and Its Four Sources (Bandura) (frontier)
- Achievement Goal Theory (Mastery vs Performance, 2x2/3x2) (frontier)
- Regulatory Focus Theory (Promotion vs Prevention, Higgins) (frontier)
- Self-Regulation, Willpower & the Ego-Depletion Replication Failure (frontier)
- Stress & Coping / Cognitive Appraisal (Lazarus & Folkman) (frontier)
- Burnout & Job Demands-Resources Model (Maslach) (frontier)
- Resilience, Recovery & Post-Traumatic Growth (Sonnentag, Tedeschi & Calhoun) (frontier)
Personality and Individual Differences ●
- Big Five / Five-Factor Model (OCEAN) (frontier)
- NEO-PI-R 30 facets (frontier)
- Lexical hypothesis (Allport & Odbert, Cattell, Tupes & Christal, Goldberg) (frontier)
- HEXACO and Honesty-Humility (Ashton & Lee) (frontier)
- Rank-order stability (Roberts & DelVecchio) (frontier)
- Mean-level change / maturity principle (Roberts, Walton & Viechtbauer) (frontier)
- State vs trait and Whole Trait Theory (Fleeson) (frontier)
- Person-situation debate (Mischel, the .30 coefficient) (frontier)
- Interactionism, situational strength, and CAPS (Mischel & Shoda) (frontier)
- Epstein aggregation principle (frontier)
- Psychometric critique of MBTI and type systems (DISC, Enneagram, True Colors) (frontier)
- Forer / Barnum effect (frontier)
- Dark Triad and Dark Tetrad (Paulhus & Williams; SD3; D-factor) (frontier)
- Heritability and the non-shared environment (twin studies) (frontier)
- Ethical application of traits to stakeholder communication (frontier)
Moral Psychology ●
- Moral Foundations Theory (frontier)
- Morality-as-Cooperation (frontier)
- Social Intuitionist Model (frontier)
- Dual-Process Theory of Moral Judgment (frontier)
- Theory of Dyadic Morality (frontier)
- Moral Licensing (frontier)
- Moral Disengagement (frontier)
- Organizational Justice (Fairness Perception) (frontier)
- Is-Ought Problem & Naturalistic Fallacy (frontier)
Psychology of Charitable Giving ●
- Warm-Glow and Impure Altruism (frontier)
- Identifiable Victim Effect (frontier)
- Singularity Effect (frontier)
- Compassion Fade (frontier)
- Psychic Numbing (frontier)
- Pseudoinefficacy (frontier)
- Empathy-Altruism Hypothesis (frontier)
- Martyrdom Effect (frontier)
- Overhead Aversion (frontier)
- Moral Identity and Self-Signaling (frontier)
- Parochial Altruism (frontier)
- Prosocial Message Framing (frontier)
- Narrative Transportation (frontier)
- Nudge and Default Effects (frontier)
Customer Satisfaction and Loyalty Science
Psychology of Human-AI Interaction (Trust & Appropriate Reliance) ●
- Calibrated Trust and the Trust-Calibration Curve (Lee & See) (frontier)
- Trust as Attitude vs. Reliance as Behavior (frontier)
- Over-trust/Over-reliance vs. Under-trust/Disuse (frontier)
- Trust Resolution and Specificity (frontier)
- Automation Bias (Commission vs. Omission Errors) (frontier)
- Automation Complacency (Parasuraman & Manzey) (frontier)
- Algorithm Aversion (Dietvorst) (frontier)
- Algorithm Appreciation (Logg) (frontier)
- Reconciling Aversion vs. Appreciation (Moderators) (frontier)
- Explanation/Transparency Effects on Reliance (Bansal) (frontier)
- Confidence Display and Miscalibrated Confidence (frontier)
- Cognitive Forcing Functions (Bucinca) (frontier)
- Human-AI Complementarity / Complementary Team Performance (frontier)
- Appropriate-Reliance Interventions (frontier)
- Anthropomorphism, AI Persona and Uncanny Valley (frontier)
- Design Principles for Calibrated Reliance (frontier)
Learning & Expertise Psychology ●
- Cognitive Load Theory (Sweller — intrinsic/extraneous/germane load, element interactivity, worked-example & expertise-reversal effects, split-attention/modality/redundancy) (frontier)
- Retrieval Practice and the Testing Effect (Roediger & Karpicke) and the Generation Effect (frontier)
- Spacing / Distributed Practice, the Ebbinghaus Forgetting Curve, and Spaced-Repetition Systems (Leitner, SM-2/Anki) (frontier)
- Interleaving vs Blocking and the Discriminative-Contrast Hypothesis (frontier)
- Desirable Difficulties (Bjork) and the Storage- vs Retrieval-Strength Model (New Theory of Disuse) (frontier)
- Elaboration, Dual Coding (Paivio), and Self-Explanation (Chi) (frontier)
- Metacognition — Judgments of Learning, the Illusion of Fluency, Calibration, Stability/Foresight Bias (frontier)
- Deliberate Practice (Ericsson), Expert Chunking (Chase & Simon), and the 10,000-Hour-Rule Critique (Macnamara) (frontier)
- Adult Learning: Andragogy (Knowles) and Bloom's Revised Taxonomy (Anderson & Krathwohl) (frontier)
- Practitioner Consensus (Dunlosky 2013, Make It Stick) and the Learning-Styles Myth (Pashler 2008) (frontier)
Health Behavior Change and Donor Registration ●
- Health Belief Model (frontier)
- Theory of Planned Behavior (frontier)
- Extended Parallel Process Model (frontier)
- COM-B and Behaviour Change Wheel (frontier)
- Willingness-Registration Gap (frontier)
- Registration Choice Architecture (frontier)
- Behavioural Insights Team RCT (frontier)
- Barriers to Organ Donor Registration (frontier)
Scientific Phylogenetics (ETE Toolkit) ●
- Phylogenetic Tree Manipulation (frontier)
- Evolutionary Event Detection (frontier)
- NCBI Taxonomy Integration (frontier)
- Tree Visualization (frontier)
Software Engineering 10
Design, languages, web and frontend, integrations, security, file formats, and repo tooling.
Web & Frontend Development 5
Frontend and visual design, browser differences, Chrome extensions, and mobile UI.
Frontend Design ● 9
HTML and CSS
- HTML5 Semantic Elements (frontier)
- CSS Properties and Selectors (frontier)
- Responsive Design (frontier)
- CSS At-Rules and Layout (frontier)
Vanilla JS UI Patterns
- Vanilla JS Review Workflow (frontier)
- DOM Manipulation Patterns (frontier)
- Event Handling Standards (frontier)
- Module and Bundling Patterns (frontier)
UI/UX Design ● 1
Editorial Micro-Typography & Type-Craft Defects ●
- Widows, orphans, runts & stranded subheads (frontier)
- Ragged-edge (rag) quality, rivers & bad line breaks (frontier)
- Kerning / tracking / letter-spacing (keming, all-caps tracking, display kerning) (frontier)
- Leading / line-height, vertical rhythm & baseline-grid alignment (frontier)
- Measure (line length / characters-per-line ~45-75) (frontier)
- Hyphenation & justification (H&J) & justified-text gaps (frontier)
- Hanging punctuation & optical margin alignment, optical vs metric kerning, optical sizing (opsz) (frontier)
- Correct glyphs (curly quotes, en/em dashes, small caps, old-style/tabular figures, ligatures, true vs faux bold/italic, fractions) (frontier)
- Type crimes (stretched/condensed faux styles, ransom-note font mixing) (frontier)
- Color Systems and Palettes (frontier)
- Typography and Font Pairing (frontier)
- Component Design Patterns (frontier)
- Dashboard and Admin UX (frontier)
- Responsive and Mobile Design (frontier)
Frontend Design UI/UX Expert
- Adaptive Front-End Design (frontier)
- Scannable Technical Data UX (frontier)
- Rendering Performance (frontier)
- UI Implementation Choices (frontier)
Accessibility and UX Review
- WCAG 2.2 Compliance (frontier)
- Keyboard Accessibility (frontier)
- ARIA and Semantic HTML (frontier)
- Focus Management (frontier)
- Landmark Regions (frontier)
Usability Heuristic Evaluation and Laws of UX
Computational Aesthetics & Automated UI-Quality Metrics
Web Design ●
- Visual Design Aesthetics (frontier)
- Layout and Color Systems (frontier)
- Design Style Translation (frontier)
- Landing Page Design (frontier)
AI-Native UX and Generative UI Design ●
- Streaming UX (TTFT, markdown buffering, smooth streaming, a11y) (frontier)
- Generative UI (Vercel AI SDK useChat/streamObject, typed parts, paused RSC, Thesys C1/OpenUI) (frontier)
- Latency masking & perceived performance (frontier)
- Trust & calibration UI (citations, confidence cascades, reasoning-trace caveat) (frontier)
- Refusal/error/fallback UX (PAIR taxonomy) (frontier)
- Human-AI steering & feedback affordances (frontier)
- Governing frameworks (Microsoft HAX 18, Google PAIR, Apple HIG, Shape of AI) (frontier)
Cross-Browser and Mobile Web Programming 5
Cross-Browser Extension and Userscript Portability
Browser Engine Differences and Feature Detection
Cross-Browser Testing and Debugging
Mobile-Web and Browser Security Differences
Web-to-Native App Packaging
Chrome Extension Development 3
Chrome Extension Security
- Extension Security Review Workflow (frontier)
- Permission Auditing (frontier)
- Content Security Policy (frontier)
- Manifest V3 Security (frontier)
- MV3 Architecture Fundamentals (frontier)
- Chrome API Reference (frontier)
- Messaging Patterns (frontier)
- Chrome DevTools MCP (frontier)
Dexie and IndexedDB Local-First
- IndexedDB Schema Design (frontier)
- Dexie.js API Patterns (frontier)
- Local-First Architecture (frontier)
- Sync and Conflict Resolution (frontier)
Platform Adapter Review
- Platform Adapter Review Workflow (frontier)
- Adapter Pattern Standards (frontier)
- Cross-Platform Compatibility (frontier)
Mobile iOS Design ●
- iOS Human Interface Guidelines (frontier)
- SwiftUI Patterns (frontier)
- Native iOS Components (frontier)
- Apple Design Principles (frontier)
Visual Design Principles as a Critique Rubric + Design-Critique Methodology
- Visual hierarchy (size/weight/contrast/position/spacing levers, typographic hierarchy, squint test, detect→rate→fix) (frontier)
- Emphasis & focal point (dominance/sub-dominance/subordination, isolation/Von Restorff, dual-equal-CTA defect) (frontier)
- Gestalt principles (proximity, similarity, closure, continuity, figure-ground, common region, common fate) as grouping violations (frontier)
- The C.R.A.P. principles (contrast, repetition, alignment, proximity) — Robin Williams (frontier)
- Balance (symmetric/asymmetric/radial, visual weight, tipping detection) (frontier)
- White space / negative space (macro vs micro, active vs passive, clutter, premium-feel, line-height/measure numerics) (frontier)
- Scale & proportion (modular scale ratios 1.25/1.333, 8-point grid, golden-ratio skepticism, 200%-zoom clipping) (frontier)
- Unity, variety & visual rhythm (monotony vs chaos) (frontier)
- Visual flow & scanning patterns (F-pattern as symptom, Z-pattern, Gutenberg diagram, layer-cake/spotted/commitment/bypassing) (frontier)
- Consistency (internal/external, Jakob's Law, aesthetic vs functional, design tokens, when-to-break) (frontier)
- Design-critique methodology (I-Like-I-Wish-What-If, Describe/Interpret/Evaluate, Rose/Bud/Thorn, design studio/charrette) (frontier)
- Connor & Irizarry Discussing Design (critique vs reaction, frame around objectives, facilitation, no problem-solving mid-crit) (frontier)
- Actionable-but-non-prescriptive feedback (problem-not-solution, ask questions, giver/receiver dynamics) (frontier)
- Severity rating & design QA (Nielsen 0–4, severity vs priority, Blocker→Cosmetic ladder, spec-parity gate) (frontier)
- Critique anti-patterns (compliment sandwich, HiPPO, bikeshedding, design-by-committee, vague praise) (frontier)
SaaS APIs & Integrations 8
Client code and CLIs for third-party platforms such as Jira, Slack, Salesforce, Glean, and eBay.
Glean Developer Integration 1
Glean Enterprise CLI ●
- Glean MCP Integration (frontier)
- Glean SDKs and APIs (frontier)
- Mozilla Glean Telemetry SDK (frontier)
- Glean Enterprise Capability Map (frontier)
Jira Developer Expert
- Jira Cloud API (frontier)
- Jira Software and Service Management (frontier)
- Forge App Development (frontier)
- Webhook Integration (frontier)
- Jira Authentication (frontier)
Monday.com Developer
- Monday Platform MCP (frontier)
- Monday App MCP (frontier)
- Monday GraphQL API (frontier)
- Monday Webhooks (frontier)
- Monday App Development (frontier)
Salesforce Developer Expert
- Salesforce REST API (frontier)
- Apex Standards (frontier)
- Case and Report APIs (frontier)
- Eventing and Webhooks (frontier)
Slack Developer Platform ●
- Slack Web API (frontier)
- Slack Events API (frontier)
- Socket Mode (frontier)
- Slack CLI (frontier)
- Authentication and Tokens (frontier)
Google Workspace CLI
- Gmail Automation (frontier)
- Calendar Management (frontier)
- Google Drive Operations (frontier)
- Sheets and Docs (frontier)
Order CLI
- Foodora Order History (frontier)
- Active Order Status (frontier)
eBay Listing Automation
- eBay API Authentication (frontier)
- Listing Creation (frontier)
- Inventory Management (frontier)
- Photo Workflow (frontier)
Security & Identity 3
Application security review, compliance auditing, and identity providers.
Security Review
- Security Review Workflow (frontier)
- Common Risk Classes (frontier)
- Authentication and Authorization Controls (frontier)
- Injection Defense Patterns (frontier)
- Security Standards (frontier)
Security Compliance Auditor
- Security Policy Audit (frontier)
- Compliance Gap Analysis (frontier)
- MongoDB AI Policy Scanning (frontier)
- Codebase Security Review (frontier)
Okta Expert ●
- Okta Authentication Flows (frontier)
- Okta API and SDK (frontier)
- Okta Operating Model (frontier)
- Identity and Access Management (frontier)
Developer Tooling & Repo Automation 2
Tools that bootstrap, analyze, and index code repositories.
Repo Bootstrapper ●
- CLAUDE.md and AGENTS.md Management (frontier)
- CI Workflow Setup (frontier)
- Docs Suite Generation (frontier)
- Repo Meta-Doc Maintenance (frontier)
Repo File Analyzer ●
- Per-File Summary Generation (frontier)
- Incremental Analysis via File Hashing (frontier)
- File Analysis Upload to Context Hub (frontier)
- High-Signal File Prioritization (frontier)
Software Engineering Patterns 10
Node.js Backend Frameworks (Fastify, NestJS, Hono) ●
- Fastify plugins and encapsulation context (frontier)
- Fastify lifecycle hooks (frontier)
- Fastify JSON Schema validation and serialization (TypeBox type-provider) (frontier)
- Fastify decorators and anti-patterns (frontier)
- NestJS modules and hierarchical DI (frontier)
- NestJS providers and scopes (frontier)
- NestJS request pipeline (Middleware/Guards/Interceptors/Pipes/Filters) (frontier)
- NestJS dynamic modules and forwardRef circular deps (frontier)
- NestJS Fastify adapter (frontier)
- Hono Context and Web-Standards core (frontier)
- Hono RegExpRouter and typed Variables/Bindings (frontier)
- Hono validation (@hono/zod-validator) and RPC mode (frontier)
- Hono edge runtimes (Cloudflare Workers/Deno/Bun/Lambda) (frontier)
- Fastify-vs-NestJS-vs-Hono framework selection (frontier)
Database Proxies & Query-Optimization Middleware
- Connection pooling & multiplexing (frontier)
- Read/write splitting & replica routing (frontier)
- Read-after-write / replication-lag staleness hazard (causal_reads, GTID sync) (frontier)
- Proxy query result caching (TTL vs invalidation) (frontier)
- Query rewriting & SQL firewall (digest allow-list) (frontier)
- Proxy-based sharding / horizontal scale-out (Vitess vtgate) (frontier)
- Failover acceleration & proxy-tier HA (SPOF, sidecar vs centralized vs Keepalived) (frontier)
- Credential brokering (IAM / Secrets Manager) (frontier)
- Proxy-vs-driver-vs-app decision framework & pool sizing (frontier)
- ProxySQL (frontier)
- MariaDB MaxScale (frontier)
- PgBouncer (frontier)
- PgCat & Pgpool-II (frontier)
- AWS RDS Proxy (frontier)
- mongos as MongoDB's native router & why MongoDB rarely uses third-party proxies (frontier)
Backend Patterns ●
- API Design Patterns (frontier)
- Database Optimization (frontier)
- Caching Strategies (frontier)
- Authentication and Authorization (frontier)
- Background Jobs and Queues (frontier)
Code Review
- Review Workflow (frontier)
- Code Quality Heuristics (frontier)
- Review Comment Writing (frontier)
- Security-Aware Review (frontier)
- PR Review Standards (frontier)
Coding Standards ●
- Naming and Readability Conventions (frontier)
- TypeScript and JavaScript Standards (frontier)
- React Best Practices (frontier)
- File Organization (frontier)
- Testing Standards (frontier)
Debugging Techniques 3
Debugging Strategies ●
- Root Cause Analysis Frameworks (frontier)
- Reproduction Checklists (frontier)
- Hypothesis Formation (frontier)
- Systematic Debugging Process (frontier)
7-Phase Debugging Workflow ●
JavaScript and Node.js Debugging
- JS Runtime Debugging (frontier)
- Node.js Diagnostics (frontier)
- CSS and HTML Validation (frontier)
- Profiling and Performance (frontier)
- Root Cause Analysis (frontier)
- Deep Trace Logging (frontier)
- Unit Testing for Bugs (frontier)
Performance Profiling Expert
- Browser Runtime Performance (frontier)
- Rendering and Interaction Analysis (frontier)
- Profiling Diagnostic Workflow (frontier)
- Performance Triage (frontier)
Software Architecture
- Architecture Decision Records (frontier)
- Views and Stakeholder Concerns (frontier)
- Architecture Documentation (frontier)
- System Design Patterns (frontier)
Testing and Vitest Expert
- Vitest Core Model (frontier)
- Mocking and Spies (frontier)
- Async Testing Patterns (frontier)
- Test Lifecycle Hooks (frontier)
- Coverage Configuration (frontier)
Web App Testing ●
- Playwright Integration (frontier)
- Frontend Functionality Verification (frontier)
- Browser Screenshot Capture (frontier)
- Browser Log Inspection (frontier)
Programming Languages 18
Python Testing with pytest, fixtures, and Hypothesis ●
- pytest fixtures (scope, conftest.py, yield/finalization, autouse, built-in fixtures) (frontier)
- Parametrization (parametrize, indirect, custom IDs, pytest_generate_tests) (frontier)
- Markers and configuration (skip/xfail/skipif, custom markers, pyproject.toml) (frontier)
- Mocking (monkeypatch, unittest.mock, pytest-mock mocker/spy) (frontier)
- Hypothesis property-based testing (@given, strategies, map/filter/flatmap, @composite, @example, shrinking, settings/database) (frontier)
- Hypothesis stateful testing (RuleBasedStateMachine, rules, invariants) (frontier)
- Async testing (pytest-asyncio, AnyIO backends) (frontier)
- Coverage (pytest-cov, branch coverage, fail-under) (frontier)
- Parallelism (pytest-xdist) (frontier)
CPython Runtime Internals (Free-Threading, Subinterpreters, JIT) ●
- Shared runtime execution model (GIL, tier-1 specializing adaptive interpreter PEP 659, PyInterpreterState/PyThreadState, immortal objects PEP 683) (frontier)
- Free-threaded no-GIL build (PEP 703/779 — biased/deferred/per-thread refcounting, mimalloc/QSBR, PyMutex, stop-the-world GC, --disable-gil/python3.14t/PYTHON_GIL/sys._is_gil_enabled) (frontier)
- C-extension free-thread compatibility (Py_mod_gil, Py_MOD_GIL_NOT_USED, PyUnstable_Module_SetGIL, cp314t wheels, ThreadSanitizer) (frontier)
- Multiple interpreters / subinterpreters (PEP 734 concurrent.interpreters + Queue + InterpreterPoolExecutor; per-interpreter GIL PEP 684; PEP 554 predecessor) (frontier)
- Copy-and-patch JIT (PEP 744 — tier-2 micro-ops, LLVM build-time stencils, --enable-experimental-jit, PYTHON_JIT) (frontier)
- Choosing free-threading vs subinterpreters vs multiprocessing vs asyncio (frontier)
Pydantic v2 Data Validation and Modeling ●
- BaseModel and field definitions (Field, Annotated constraints) (frontier)
- Validators (field_validator/model_validator, before/after/wrap/plain modes) (frontier)
- Strict vs lax coercion and ConfigDict (frontier)
- Serialization (model_dump/model_dump_json, aliases, include/exclude, computed_field, RootModel) (frontier)
- TypeAdapter for non-model types (frontier)
- Discriminated (tagged) unions (frontier)
- pydantic-settings (BaseSettings, env/.env/secrets) (frontier)
- ValidationError handling (frontier)
- pydantic-core (Rust) architecture and performance (frontier)
- V1 to V2 migration and anti-patterns (frontier)
Python Static Type Checking ●
- Gradual typing model (PEP 483/484, Any, the gradual guarantee) (frontier)
- Type distribution (PEP 561, py.typed, types-* stub packages, typeshed) (frontier)
- typing-spec conformance suite (frontier)
- Inference divergence (list[int] vs list[Unknown]) (frontier)
- mypy (reference impl, --strict, plugins, mypy.ini/[tool.mypy]) (frontier)
- Pyright (five strictness levels, reportXxx, Pylance, BasedPyright) (frontier)
- Astral ty (Rust, Salsa incremental, intersection/negation types, beta 0.x) (frontier)
- Meta Pyrefly (Rust, Pyre successor, pyrefly infer, stable 1.0.0) (frontier)
- Checker selection (existing vs new project, IDE, CI gate) (frontier)
- Migrating an untyped codebase (ratchet strictness, per-module overrides) (frontier)
- Type-checker anti-patterns (Any creep, blanket type: ignore, runtime-enforcement assumption) (frontier)
CPython Performance Profiling and Acceleration ●
- Deterministic profiling (cProfile/profile + pstats, SortKey, ncalls/tottime/cumtime, calibration, snakeviz/gprof2dot) (frontier)
- Statistical/sampling profilers (py-spy record/top/dump, --native/--gil/--subprocesses, speedscope/flamegraph, Austin) (frontier)
- Scalene (line-level CPU+GPU+memory, Python-vs-native-vs-system separation, copy-volume, AI suggestions) (frontier)
- memray (Bloomberg allocation profiler, native tracking, flamegraph/table/tree, live mode, leaks/temporal, pytest-memray) (frontier)
- line_profiler/kernprof per-line CPU and py-heat (frontier)
- Benchmarking (timeit, pyperf, pytest-benchmark, CI perf budgets) (frontier)
- Flame-graph interpretation (self vs cumulative, speedscope views) (frontier)
- Native-acceleration ladder (Cython cdef/typed-memoryviews/nogil/prange, Numba @njit, mypyc, PyO3/Rust, ctypes/cffi) (frontier)
Python in the Browser & WebAssembly (Pyodide, PyScript, WASI/CPython) ●
- CPython→WASM compile pipeline (wasm32-emscripten tier 3 / wasm32-wasi tier 2, PEP 11 tiers, PEP 776/816, single-threaded WASM model) (frontier)
- Pyodide — CPython on Emscripten distribution (loadPyodide, runPython/runPythonAsync, loadPackage, micropip) (frontier)
- JS⟺Python FFI (PyProxy/JsProxy, toJs/to_js, create_proxy, destroy lifetime management, PEP 818 upstreaming) (frontier)
- PyScript framework (polyscript core, <script type=py>/<script type=mpy>, py-config/pyscript.toml, PyWorker, py-editor) (frontier)
- Pyodide vs MicroPython runtime tradeoff (~11-15 MB CPython+SciPy stack vs ~300 KB <100ms MicroPython) (frontier)
- WASM packaging — PEP 783 pyodide_* wheel tags + PyEmscripten ABI (pyodide build/cibuildwheel, one ABI per Python version) (frontier)
- WASI/CPython server-side target (wasmtime, capability-gated FS/net, sandboxed plugins, host functions) (frontier)
- WASM constraints & troubleshooting (no threads/multiprocessing, no raw sockets, web-worker offloading, cold-start size, in-memory virtual FS) (frontier)
- Cloudflare Python Workers (embedded Pyodide at the edge) (frontier)
Python Concurrency (asyncio, Structured Concurrency, anyio/trio)
- Async execution model (event loop, coroutines, tasks, awaitables, cooperative scheduling) (frontier)
- Structured concurrency with asyncio.TaskGroup 3.11+ (vs gather, ExceptionGroup, except*) (frontier)
- Cancellation & timeouts (CancelledError re-raise, asyncio.timeout 3.11+, uncancel, shield) (frontier)
- Fire-and-forget GC trap + background-task-set pattern + eager task factory 3.12 (frontier)
- anyio & trio (nurseries, cancel scopes, portability layer, why anyio for libraries) (frontier)
- Bridging to threads/processes (asyncio.to_thread, run_in_executor) (frontier)
- Async toolbox (Lock/Semaphore/Queue, async iterators/generators, async context managers) (frontier)
- PEP 789 (no yield across TaskGroup) + common pitfalls (blocking loop, swallowing cancel) (frontier)
Python CLI & TUI Application Development
- argparse (stdlib subcommands, type coercion) (frontier)
- Click (decorator groups, parameter types, context, CliRunner testing) (frontier)
- Typer (type-hint driven, Annotated idiom, built on Click) (frontier)
- CLI library selection (argparse vs Click vs Typer) (frontier)
- Rich (console markup, tables, progress, RichHandler, tracebacks) (frontier)
- Textual (widgets, reactive attributes + watch methods, messages, TCSS, workers, browser serve) (frontier)
- Entry points / [project.scripts] + exit codes + testing through the runner (frontier)
Python Metaprogramming & the Data Model
- Data model / dunder protocols (__getattr__/__getattribute__/__call__, __slots__) (frontier)
- Descriptors (__get__/__set__/__delete__, data vs non-data precedence, __set_name__) (frontier)
- Class-creation pipeline (namespace → __set_name__ → __init_subclass__ → metaclass) (frontier)
- __init_subclass__ (lightweight metaclass alternative, subclass kwargs, registries) (frontier)
- Metaclasses (type, __new__/__init__/__call__/__prepare__, conflicts, when to use) (frontier)
- Protocols (structural typing, runtime_checkable) vs ABCs (nominal, abstractmethod, __subclasshook__) (frontier)
- Runtime introspection (inspect, typing.get_type_hints, annotationlib/PEP 649) (frontier)
- Discipline — restraint hierarchy, tool-followability (frontier)
Packaging Python Apps as Standalone Distributables
- Distribution spectrum (needs-Python vs bundled-interpreter vs compiled) (frontier)
- zipapp / shiv / pex (self-contained zipapps, target needs Python) (frontier)
- PyInstaller (bundles interpreter, onefile vs onedir, hidden imports, hooks) (frontier)
- Nuitka (compiles to C/native, 2-4x perf, standalone/onefile) (frontier)
- GUI/mobile & single-binary (Briefcase/BeeWare, cx_Freeze, PyOxidizer) (frontier)
- Cross-platform realities (no cross-compile, antivirus/signing/notarization) (frontier)
- Pitfalls (hidden imports, data files via importlib.resources, size, startup cost) (frontier)
Python Logging & Application Observability
- Stdlib logging model (loggers/handlers/formatters/filters, hierarchy, propagation, levels) (frontier)
- Configure-once at entry (dictConfig) + libraries use NullHandler only (frontier)
- Structured logging rationale (JSON key-value events for machine parsing) (frontier)
- structlog (processor pipeline, bound loggers, contextvars, stdlib integration, JSONRenderer) (frontier)
- loguru (zero-config, sinks, InterceptHandler to bridge stdlib, exception diagnose) (frontier)
- OpenTelemetry logs (LoggingHandler, OTLP, log<->trace correlation via trace/span IDs) (frontier)
- Best practices (context via contextvars, no secrets, exc_info, QueueHandler, double-logging pitfall) (frontier)
Python Data Modeling (dataclasses, attrs, msgspec)
- Decision: trusted/internal vs untrusted/external; performance tiers (msgspec<attrs~dataclasses<<pydantic) (frontier)
- dataclasses (field/default_factory, frozen/slots/kw_only, __post_init__, asdict) (frontier)
- attrs (@define, validators/converters, slots default, cattrs serde) (frontier)
- msgspec.Struct (fastest init+serde, auto __slots__, JSON/msgpack) (frontier)
- pydantic-v2 pointer (untrusted-data validation boundary) (frontier)
- stdlib shapes (NamedTuple, TypedDict + Required/NotRequired, enum/StrEnum/Flag) (frontier)
- Serialization (json/orjson/msgspec/pickle-insecurity) + mutable-default & slots pitfalls (frontier)
Python AST, Codegen & Source Transformation
- ast module (parse, NodeVisitor/NodeTransformer, fix_missing_locations, compile, unparse 3.9+, literal_eval) (frontier)
- AST is lossy -> when you need a CST (frontier)
- LibCST (lossless CST, matchers, metadata, codemod framework, 3.0-3.14) (frontier)
- Import hooks (sys.meta_path finders/loaders, source_to_code, PEP 302/451) (frontier)
- Code generation (ast.unparse, astor/astunparse, compile+exec, string templating tradeoff) (frontier)
- Use cases (linters/formatters, codemods, instrumentation, DSLs/PEP 750) (frontier)
- Pitfalls (AST version drift, locations, exec/eval/pickle security, round-trip loss) (frontier)
Rust Language and Rust for Blockchain ●
- Ownership, borrowing, lifetimes and the borrow checker (move semantics, NLL, Polonius) (frontier)
- Smart pointers and interior mutability (Box/Rc/Arc/RefCell/Weak, Rc<RefCell> pattern, deref coercion) (frontier)
- Traits, generics and dispatch (coherence/orphan rule, associated types, monomorphization, dyn vs impl Trait, dyn-compatibility) (frontier)
- Error handling and the ? operator (Option/Result, thiserror vs anyhow, panic-vs-Result) (frontier)
- Closures and iterators (Fn/FnMut/FnOnce, lazy zero-cost iterator chains, IntoIterator) (frontier)
- Concurrency: Send/Sync, threads, Mutex/RwLock/Arc, atomics, channels, rayon (frontier)
- Async/await and tokio (lazy futures, executors, tokio::sync, select!, spawn_blocking, Pin/Unpin, function coloring) (frontier)
- Macros: declarative (macro_rules!) and procedural (syn/quote/proc-macro2) (frontier)
- Cargo toolchain: manifest, features and unification, profiles, workspaces, editions (2015-2024) (frontier)
- no_std and embedded Rust (core/alloc, embedded-hal, Embassy, RTIC, probe-rs) (frontier)
- The WASM target (wasm-bindgen/wasm-pack, wasm32-wasip1/p2, Component Model/WASI) (frontier)
- Rust idioms and anti-patterns (newtype, builder, typestate, illegal-states-unrepresentable, clippy) (frontier)
- Rust-on-Solana programming surface and the Anchor framework (PDAs, CPI, accounts, Borsh, compute budget) (frontier)
- CosmWasm smart contracts (actor model, instantiate/execute/query, cw-storage-plus) (frontier)
- ink! contracts on Polkadot (pallet-revive/PolkaVM migration, SCALE codec) (frontier)
- Substrate/FRAME: building app-chains/runtimes vs deploying contracts (frontier)
JavaScript and Node.js 17
Node.js Concurrency Internals ●
- libuv event loop phases (timers, pending callbacks, idle/prepare, poll, check, close) (frontier)
- Microtask ordering (process.nextTick queue + Promise microtask queue, starvation) (frontier)
- setTimeout(0) vs setImmediate ordering (frontier)
- libuv thread pool (UV_THREADPOOL_SIZE 4->1024; fs/dns.lookup/crypto/zlib) (frontier)
- Don't block the event loop (sync APIs, ReDoS, partitioning vs offloading, event-loop lag) (frontier)
- Streams and backpressure (highWaterMark, write()/false, drain, pipe vs pipeline) (frontier)
- Stream types and custom streams (Readable/Writable/Duplex/Transform, push/write rules, cork/uncork) (frontier)
- worker_threads (V8 isolates, structured clone, transferList, SharedArrayBuffer/Atomics, MessageChannel) (frontier)
- cluster (SCHED_RR vs SCHED_NONE, shared server ports, worker lifecycle, built on child_process.fork) (frontier)
- child_process (spawn/exec/execFile/fork, shell command-injection, maxBuffer, IPC, detached/unref) (frontier)
- Web Streams API (WHATWG) & Node interop (ReadableStream/WritableStream/TransformStream, Readable.toWeb/fromWeb, stream/consumers) (frontier)
JavaScript/TypeScript Runtimes (Deno, Bun, Edge) & WinterTC Interop ●
- WinterTC / WinterCG Minimum Common Web Platform API (ECMA-429) + Runtime Keys (frontier)
- Deno 2.x runtime (Node/npm compat, npm:/node: specifiers, deno.json, JSR, Deno KV/Queues, secure-by-default perms, LTS) (frontier)
- Bun 1.x runtime + package manager (JavaScriptCore, bun install, text bun.lock, isolated installs, Bun.serve/bun:sqlite/Bun.sql/Bun.s3, bun test, bundler) (frontier)
- Edge runtimes (Cloudflare Workers/workerd nodejs_compat + compatibility dates + unenv, Vercel Edge Runtime, Deno Deploy isolates/subhosting) (frontier)
- Choosing & migrating between Node/Deno/Bun/edge (portability via Minimum Common API + Runtime-Key exports) (frontier)
Node.js Native TypeScript, Permission Model & Single Executable Applications ●
- Native TypeScript type stripping (flags/versions, erasableSyntaxOnly, unsupported enum/namespace/parameter-properties, removed --experimental-transform-types, .ts/.mts/.cts + mandatory import extensions, no-type-check caveat) (frontier)
- tsx and ts-node runners (esbuild transpile vs tsc type-check, decorators/JSX/path-aliases, when native stripping isn't enough) (frontier)
- The 24.x Permission Model (--permission, --allow-fs-read/-fs-write/-child-process/-worker/-addons/-wasi/-inspector, process.permission.has(), node.config.json, worker-non-inheritance + symlink/FD-bypass limits) (frontier)
- Single Executable Applications (sea-config.json, --build-sea v25.5, postject + NODE_SEA_BLOB sentinel fuse, node:sea API isSea/getAsset/getRawAsset/getAssetKeys, CJS vs ESM SEA, codesign/signtool) (frontier)
- Node 24/25/26 LTS toolchain baseline (build-step elimination philosophy, version timeline) (frontier)
V8 Engine Internals (hidden classes / inline caches, JIT pipeline, Orinoco GC) ●
- Hidden classes / Maps / object shapes (DescriptorArrays, TransitionArrays, transition trees) (frontier)
- Property storage (in-object, backing store, dictionary/slow mode, elements kinds) (frontier)
- Inline caches and the monomorphic/polymorphic/megamorphic ladder (frontier)
- JIT tiering pipeline: Ignition interpreter -> Sparkplug baseline (frontier)
- Maglev mid-tier (SSA/CFG) and TurboFan top-tier (sea-of-nodes) (frontier)
- Turboshaft / Turbolev direction (frontier)
- Speculative optimization and deoptimization (eager/lazy/soft bailouts, ~70 reasons) (frontier)
- Diagnostic flags (--trace-opt, --trace-deopt, --trace-ic, %OptimizeFunctionOnNextCall) (frontier)
- Orinoco generational GC: parallel Scavenger (Cheney semi-space) (frontier)
- Major GC Mark-Sweep-Compact, concurrent/incremental marking, write barriers, idle-time GC (frontier)
- Node.js GC tuning (--max-old-space-size, --max-semi-space-size, --trace-gc, perf_hooks GC observer, container sizing) (frontier)
- V8-friendly JS patterns and megamorphism anti-patterns (frontier)
JavaScript Build Tooling and Bundlers ●
- Vite and Rolldown (frontier)
- esbuild (frontier)
- Rollup (frontier)
- Webpack (frontier)
- Rspack (frontier)
- Turbopack (frontier)
- Oxc and oxlint (frontier)
- SWC (frontier)
- Babel (frontier)
- Biome (frontier)
- ESLint Flat Config (frontier)
- Prettier (frontier)
- Dev Server vs Production Build (frontier)
- Bundler Migration (frontier)
- Rust Toolchain Wave (VoidZero) (frontier)
Web Platform and Browser APIs ●
- DOM and Events (frontier)
- Fetch Streams and AbortController (frontier)
- Web Components and Shadow DOM (frontier)
- Service Workers and PWA (frontier)
- Client Storage (IndexedDB, Cache, OPFS) (frontier)
- Observer APIs (Intersection, Resize, Mutation, Performance) (frontier)
- Real-Time Transports (WebSocket, WebRTC, WebTransport, SSE) (frontier)
- Web Workers and SharedArrayBuffer (frontier)
- Web Crypto (frontier)
- Navigation API (frontier)
- View Transitions API (frontier)
- WebGPU and Canvas (frontier)
Node.js Native Addons (N-API, node-gyp, node-addon-api) ●
- Node-API (N-API) C ABI (frontier)
- node-addon-api C++ wrapper (frontier)
- node-gyp / binding.gyp build toolchain (frontier)
- Prebuilt binary distribution (prebuildify, node-pre-gyp) (frontier)
- cmake-js (frontier)
- Rust addons (napi-rs, neon) (frontier)
- Loading and debugging .node addons (frontier)
Node.js Production Diagnostics & Profiling ●
- Inspector / Chrome DevTools Protocol (--inspect/--inspect-brk/--inspect-wait, inspector.Session, CDP over WebSocket) (frontier)
- Programmatic profiling via node:inspector (Profiler.* / HeapProfiler.* domains) (frontier)
- V8 profilers as CLI flags (--prof/--prof-process tick processor, --cpu-prof, --heap-prof) (frontier)
- Heap snapshots & three-snapshot memory-leak hunting (--heapsnapshot-signal, --heapsnapshot-near-heap-limit, retainer analysis) (frontier)
- perf_hooks measurement (PerformanceObserver, monitorEventLoopDelay histogram, eventLoopUtilization for pool sizing, timerify, createHistogram) (frontier)
- diagnostics_channel + TracingChannel (zero-idle-cost instrumentation, built-in http/net channels, bindStore) (frontier)
- Diagnostic reports (--report-*) & trace_events (--trace-event-categories) (frontier)
- Ecosystem tools: clinic.js (doctor/flame/bubbleprof), 0x flamegraphs, autocannon load-driven profiling (frontier)
Node.js HTTP & Networking ●
- node:http server lifecycle, IncomingMessage/ServerResponse, http.request, http.Agent (frontier)
- node:http server & socket timeouts (headersTimeout/requestTimeout/keepAliveTimeout/maxRequestsPerSocket) (frontier)
- node:http2 (secure/insecure servers, sessions/streams, ALPN, server push, compatibility API) (frontier)
- node:https + node:tls (createSecureContext, SNI, ALPN, session resumption) (frontier)
- node:net TCP connection model (allowHalfOpen, Nagle/setNoDelay, setKeepAlive, BlockList) (frontier)
- node:dgram UDP sockets and multicast (frontier)
- The global fetch as undici (Dispatcher/Client/Pool/Agent, interceptors, RetryAgent/ProxyAgent/MockAgent, setGlobalDispatcher) (frontier)
- undici keep-alive & timeout options (pipelining, keepAliveTimeout, keepAliveMaxTimeout, headersTimeout, bodyTimeout) (frontier)
Node.js Module Resolution & ESM/CJS Interop ●
- The CommonJS require(X) resolution algorithm (frontier)
- The ESM resolution algorithm (ESM_RESOLVE) (frontier)
- package.json exports — conditional exports, subpaths, patterns, encapsulation (frontier)
- package.json imports — private #internal specifiers (frontier)
- The dual-package hazard (frontier)
- ESM <-> CJS interop: require(esm), importing CJS, createRequire (frontier)
- Module customization (loader) hooks (module.register / registerHooks) (frontier)
- Import attributes, JSON modules, and import maps (frontier)
Node.js Modern Batteries-Included Built-ins ●
- node:sqlite (DatabaseSync/StatementSync, params, aggregate, backup) — replaces better-sqlite3 (frontier)
- Global undici-backed WebSocket client (client-only) — replaces ws for client use (frontier)
- Environment files: --env-file / --env-file-if-exists / process.loadEnvFile() / util.parseEnv() — replaces dotenv (frontier)
- Task running & watch: node --run + --watch / --watch-path / --watch-preserve-output — replaces npm run / nodemon (frontier)
- Filesystem & utils: fs.glob/globSync, util.styleText(), structuredClone, navigator — replace glob/chalk/lodash.cloneDeep/os.cpus (frontier)
- Module compile cache: module.enableCompileCache() / NODE_COMPILE_CACHE — startup performance (frontier)
- CLI app building with built-ins (util.parseArgs, readline/promises, signals, exit codes) (frontier)
Node.js Async Control-Flow, Errors & Context Propagation ●
- Cancellation with AbortController / AbortSignal (signal, reason, 'abort', throwIfAborted) (frontier)
- Composing signals — AbortSignal.timeout() and AbortSignal.any() (frontier)
- Structured errors — Error.cause, AggregateError, custom error classes (frontier)
- The error.code convention — match on code, never message (frontier)
- Process-level failure — unhandledRejection / uncaughtException / rejectionHandled and exit semantics (frontier)
- Promise concurrency — all vs allSettled vs any vs race + concurrency limiting (frontier)
- Context propagation — AsyncLocalStorage (+ async_hooks / AsyncResource) (frontier)
Node.js Built-in Test Runner (node:test deep features) ●
- Test structure: test/describe/it, subtests, and the TestContext (frontier)
- Lifecycle hooks: before/after/beforeEach/afterEach (+ hook options) (frontier)
- Mocking functions, methods, getters/setters, and properties (mock.fn/method) (frontier)
- Mocking time: mock.timers (frontier)
- Module mocking: mock.module() (--experimental-test-module-mocks) (frontier)
- Coverage, reporters, and the filtering/execution model (--test-* flags, isolation, sharding) (frontier)
- Snapshots (t.assert.snapshot) and assertions (node:assert/strict + t.assert.*) (frontier)
Node.js Package Management & Supply-Chain ●
- The package managers — npm / pnpm / Yarn Berry (PnP) / bun install models and node_modules layout (frontier)
- Lockfiles and the reproducible-install contract (npm ci vs install, integrity hashes) (frontier)
- Workspaces / monorepos and the workspace: protocol (frontier)
- Dependency resolution & semver (ranges, dedupe, overrides, peerDependencies, optionalDependencies, engines) (frontier)
- npm scripts & lifecycle (pre/post hooks, install hooks, node --run skip) (frontier)
- Supply-chain security (npm audit, provenance/sigstore, install-scripts defense, dependency confusion, lockfile injection, corepack pinning) (frontier)
Node.js Application Security Hardening ●
- Prototype pollution (attack + defenses) (frontier)
- Injection in Node (command/path/eval/SQL-NoSQL) (frontier)
- Hardening flags & runtime defenses (incl. Permission Model as defense-in-depth) (frontier)
- Secrets & configuration hygiene (frontier)
- Dependency & supply-chain risk (frontier)
- Request-layer risks (SSRF, ReDoS, smuggling, unsafe deserialization) (frontier)
Node.js Build Tooling & Bundlers ● 1
@vercel/ncc (single-file compilation for CLIs/Actions/Lambda) ●
- The bundle-vs-ship-source decision for Node backends (tree-shaking, DCE, minification) (frontier)
- esbuild (transform vs build API, platform:node, format, external/packages, no type-checking) (frontier)
- swc (@swc/core, .swcrc, Rust speed, decorators/metadata, swc vs esbuild) (frontier)
- tsup (esbuild wrapper, dual ESM+CJS, .d.ts generation, the library-build sweet spot) (frontier)
- Rollup (output formats, tree-shaking, code-splitting, plugin ecosystem, when over esbuild) (frontier)
- Source maps for Node (--enable-source-maps) + tsconfig path-alias resolution in bundles (frontier)
- tsx / native TS for dev vs a bundler for prod (frontier)
Node.js & TypeScript ORMs and Query Builders ●
- Prisma — schema-first ORM with a generated client (frontier)
- Drizzle ORM — SQL-first, no codegen, no runtime engine (frontier)
- Kysely — a type-safe query builder (not an ORM) (frontier)
- TypeORM, Sequelize & MikroORM — entities, decorators, the AR/DM split (frontier)
- Migrations strategy (cross-cutting) (frontier)
- The N+1 problem, eager/lazy loading & DataLoader (cross-cutting) (frontier)
- Transactions, pooling, raw SQL & repositories (cross-cutting) (frontier)
- JavaScript Language Reference (frontier)
- Node.js Runtime APIs (frontier)
- Async Patterns (frontier)
- Module Systems (frontier)
- Coding Standards and Best Practices (frontier)
TypeScript Expert 9
TypeScript Advanced Types ●
TypeScript Compiler Configuration ●
TypeScript Declaration Files ●
TypeScript Compiler API ●
TypeScript Decorators ●
TypeScript Project References ●
TypeScript Compiler Performance and tsgo ●
TypeScript ESLint Typed Linting ●
TypeScript Migration and Adoption ●
- Type System Core Model (frontier)
- Control Flow Analysis (frontier)
- Generics and Reusable APIs (frontier)
- TypeScript Best Practices (frontier)
Python Patterns and Best Practices 2
uv — The Unified Python Toolchain ●
- Project & workspace management (uv init/add/remove/sync/run/lock/tree, [dependency-groups] PEP 735, [tool.uv.sources], multi-package workspaces with shared uv.lock) (frontier)
- Universal lockfile (uv.lock cross-platform marker resolution, --resolution highest/lowest/lowest-direct, --prerelease, --fork-strategy, --locked/--frozen/--check, requires-python subset rule) (frontier)
- Lockfile export & interop (uv export to requirements.txt / pylock.toml PEP 751 / CycloneDX SBOM) (frontier)
- Python version install & pinning (uv python install/pin/list/find, .python-version, python-preference managed vs system, UV_PYTHON_DOWNLOADS) (frontier)
- Tool / pipx replacement (uvx / uv tool run ephemeral, uv tool install/upgrade/list/update-shell) (frontier)
- pip-compatible interface (uv pip install/compile --universal/sync, uv venv, --system) (frontier)
- Build backend & publishing (uv_build default since 2025, uv build, uv publish) (frontier)
- PEP 723 inline-script metadata (uv run script.py, uv add --script, --with) (frontier)
- Configuration & cache ([tool.uv]/uv.toml, UV_* env vars, [[tool.uv.index]], content-addressed cache) (frontier)
Python Supply-Chain & Application Security ● 1
Python supply-chain threat landscape 2025-2026
- Brand-verification gaps in package-registry organization/namespace accounts (frontier)
- Defensive namespace squatting on public package registries (frontier)
- Dependency confusion and namespace shadowing (frontier)
- Domain resurrection attacks against package-registry account recovery (frontier)
- Ephemeral/isolated CI runners as a secret-exposure-window mitigation (frontier)
- GhostAction GitHub Actions secret exfiltration campaign (frontier)
- GitHub Actions workflow-file injection via compromised maintainer accounts (as a distinct sub-technique from token/dependency compromise) (frontier)
- LLM package-hallucination benchmarking across models and languages (frontier)
- OIDC Trusted Publishing architecture (PyPI/npm/RubyGems) (frontier)
- PEP 740 / Sigstore publish attestations and consumer-side verification (frontier)
- PEP 766 index-priority vs version-priority resolution semantics (frontier)
- Poetry explicit-source transitive-dependency resolution bugs (frontier)
- PyPI Project Quarantine lifecycle and false-positive restoration (frontier)
- PyPI phishing and maintainer account takeover (frontier)
- PyPI project lifecycle status standardization (PEP 792: active/archived/deprecated/quarantined) (frontier)
- Shai-Hulud self-replicating package worm (frontier)
- TruffleHog and secret-scanner dual-use (defensive tool repurposed offensively) (frontier)
- Typosquatting and name-confusion attacks on PyPI (frontier)
- npm postinstall/lifecycle-script execution as an attack surface (frontier)
- Dependency auditing (pip-audit — PyPA, OSV + PyPA Advisory DB, -r/PEP 751 lockfile input, --fix, cyclonedx output) (frontier)
- SBOM generation (CycloneDX vs SPDX, cyclonedx-py, syft, lib4sbom, PEP 770 SBOMs-in-wheels) (frontier)
- Static application security testing (bandit — PyCQA AST plugins, B-codes, severity×confidence, [tool.bandit]/# nosec, baseline workflow) (frontier)
- Provenance — sigstore/PEP 740 digital attestations + Trusted Publishing OIDC (keyless signing, gh-action-pypi-publish ≥1.11.0, pypi-attestations verify) (frontier)
- Hash-pinned reproducible installs (pip --require-hashes, pip-compile --generate-hashes, uv lock) (frontier)
- CI/pipeline hardening (OpenSSF Scorecard, zizmor, SHA-pinned Actions) (frontier)
Compose Multiplatform Patterns ●
- State Management in KMP (frontier)
- Navigation Patterns (frontier)
- Platform-Specific UI (frontier)
- Performance Optimization (frontier)
Software Engineering & Distributed Computing 1
Distributed Systems & Consensus (theory + blockchain mechanisms) ●
- Crash-fault consensus algorithms (Paxos/Multi-Paxos, Raft, Viewstamped Replication, Zab) and the leader-based-log skeleton they share (frontier)
- Byzantine fault tolerance (PBFT three-phase, HotStuff linear view-change, Tendermint/CometBFT, the 3f+1 bound, BFT-SMR) (frontier)
- Consistency models hierarchy (linearizability, sequential, causal+, eventual) + the CALM theorem (monotonicity = coordination-free) (frontier)
- Impossibility & tradeoff results (FLP, CAP/PACELC, safety-vs-liveness, consensus<->atomic-broadcast equivalence) (frontier)
- Logical time & causality (Lamport clocks, vector clocks, happens-before) (frontier)
- Quorum systems & quorum intersection (majority 2f+1, Byzantine f-masking/disseminating, Flexible Paxos phase-quorum-only intersection) (frontier)
- Nakamoto/longest-chain Proof of Work (probabilistic finality, honest-majority assumption, GHOST/heaviest-chain fork-choice) (frontier)
- Proof of Stake mechanisms (Ethereum Gasper = Casper FFG + LMD-GHOST, Cardano Ouroboros Praos/Genesis, Solana Tower BFT + PoH) (frontier)
- Blockchain finality models (probabilistic vs deterministic/economic; finality gadget vs fork-choice rule) (frontier)
- Sybil resistance & the scalability-security-decentralization trilemma (permissionless identity cost) (frontier)
- Consensus-layer attacks (selfish mining, nothing-at-stake, long-range, grinding/RANDAO, balancing/bouncing on Gasper) (frontier)
- Gossip/epidemic protocols (anti-entropy, rumor-mongering, SWIM) & CRDTs (state vs op-based, Strong Eventual Consistency) (frontier)
Document & File Formats ● 4
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Markdown ● 8
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Markdown Authoring & Spec (CommonMark/GFM) ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Markdown Processing & ASTs (unified/remark/rehype) ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
MDX (Markdown + JSX) ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
llms.txt & Markdown-for-LLMs ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Pandoc Document Conversion ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Docs-as-Code & Static-Site Generators ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Lightweight Markup Languages (reST/AsciiDoc/Org) ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Markdown Linting & Quality Gates ●
Hub for **programmatic document and data-file work**: creating, parsing, editing, and converting the common office and data formats in Python and Node.js.…
Excel and Spreadsheet Automation ●
- XLSX File Creation and Editing (frontier)
- Financial Model Formulas (frontier)
- Tabular Data Cleaning (frontier)
- CSV and TSV Conversion (frontier)
Word Document Manipulation ●
- DOCX File Creation (frontier)
- DOCX Editing and Formatting (frontier)
- Table of Contents Generation (frontier)
- Image Insertion (frontier)
Document Store Bootstrapper ●
- Google Drive Engagement Folders (frontier)
- Document Taxonomy Design (frontier)
- Index and Metadata Standards (frontier)
- Archival Policy (frontier)
Indexing ● 5
ORM index definitions ●
Query planner, explain plans and covered queries ●
Search and vector indexes ●
Index lifecycle and health ●
Index types ●
Apple Platform Publishing (Mac App Store) 19
Shipping macOS apps to the Mac App Store: App Review rules, sandbox networking, menu-bar UX, release QA and frontier capabilities.
Mac App Store App Review Guidelines for Sandboxed Utilities
- App Review Board appeal process (frontier)
- Apple trademark usage in app names (Mac, macOS) (frontier)
- CPython --with-app-store-compliance (frontier)
- Event-driven network change detection (SCDynamicStore/NWPathMonitor) (frontier)
- Guideline 2.1 Information Needed reply: review notes (frontier)
- Guideline 2.3 accurate metadata and 4.2 minimum functionality and hidden-feature strings (frontier)
- Guideline 2.4.2 power and resource efficiency for polling network monitors (frontier)
- Guideline 2.5 public APIs and bundled interpreter and private-API string scan (ITMS-90338) (frontier)
- Guideline 5.2 trademark and IP rules in app metadata (frontier)
- Mac App Store Guideline 2.4.5 sandbox self-contained bundle and no-root rules (frontier)
- Metadata-only resubmission (frontier)
- Notes for Review feature inventory for menu-bar utilities (frontier)
- Reading the ITMS-90338 symbol list with swift-demangle (frontier)
- Resolution Center reply mechanics (frontier)
- Review notes template for menu-bar app (frontier)
- SMAppService login item consent (frontier)
- Sandbox entitlements for network monitoring (frontier)
- Screenshot and preview rules for macOS (2.3.3, 2.3.4) (frontier)
- Third-party API terms-of-use evidence under 5.2.2 (frontier)
- Timer tolerance and wakeup coalescing (frontier)
- py2app bundle slimming (excluding tkinter/curses) (frontier)
- py2app nested code signing for App Store (frontier)
- screen recording and resubmission protocol (frontier)
App Review Privacy, AI Consent and Rejection Playbook
- App Privacy nutrition labels age rating export compliance and DSA trader status (frontier)
- App Review process mechanics Resolution Center appeals and recurring rejection causes for utility and network apps (frontier)
- BIS annual self-classification report (frontier)
- BYO API key consent design (frontier)
- DAC7 and Business-section compliance entries (frontier)
- Declared Age Range API (frontier)
- Developer ID notarization as alternative to Mac App Store review (frontier)
- Guideline 5.1.1 and 5.1.2(i) privacy purpose strings and third-party AI data-sharing consent (frontier)
- Info.plist usage description keys on macOS (frontier)
- Notes for Review template for optional BYO-key features (frontier)
- Privacy manifests and required-reason APIs for Mac apps (frontier)
- Privacy policy requirements under 5.1.1(i) (frontier)
- Review-environment reality: reviewer first launch on a clean account network and latest macOS (frontier)
- Testing on an Internet Sharing NAT64 network (frontier)
- Writing Review Notes for optional features (frontier)
macOS App Sandbox Networking and Entitlements
- AllowedWiFiLocalNetworkAddresses CI configuration (frontier)
- App Sandbox network entitlements client and server semantics UDP ICMP and child-process inheritance (frontier)
- Background Task Management and System Settings Login Items approval (frontier)
- CWWiFiClient event monitoring without Location (frontier)
- CoreWLAN SSID access and Location Services authorization (frontier)
- Embedding a helper tool in a sandboxed app (frontier)
- Hardened Runtime Gatekeeper and notarization for a Developer ID twin build (frontier)
- Interface-bound sockets IP_BOUND_IF and required_interface and sandbox behaviour (frontier)
- Local Network privacy TN3179 NSBonjourServices and detecting a denial (frontier)
- Location usage-string wording for App Review (frontier)
- NECP and includeAllNetworks routing precedence (frontier)
- NWBrowser waiting-state handling for -65570 (frontier)
- NWConnection waiting state and viability handlers (frontier)
- NWParameters requiredInterface vs prohibitedInterfaceTypes (frontier)
- NWPathMonitor requiredInterfaceType and prohibitedInterfaceTypes (frontier)
- Network.framework NWPathMonitor and NWConnection versus SCNetworkReachability (frontier)
- Notarized Developer ID daemon registration (frontier)
- Notarytool CI automation (frontier)
- Provisioning profiles for Developer ID sandboxed builds (frontier)
- SCDynamicStore for DNS and interface change notifications (frontier)
- SMAppService login items and privileged helpers for Mac App Store versus Developer ID (frontier)
- Sparkle or auto-update signing for the twin (frontier)
- TCC responsible-code inheritance for SMAppService agents (frontier)
- XPC from sandboxed app to loginItem helper (frontier)
- XPC service privilege separation (frontier)
- launchd agent AssociatedBundleIdentifiers for helper attribution (frontier)
macOS Menu-Bar App Design
- Accessibility for menu bar apps VoiceOver and App Store Accessibility Nutrition Labels (frontier)
- Briefcase macOS App Store packaging (frontier)
- Contrast testing on transparent menu bar (frontier)
- Dark mode semantic colours and SF Symbols in status items (frontier)
- HIG for menu bar extras windows and notifications and Liquid Glass icons Icon Composer (frontier)
- Icon Composer .icon to Assets.car build from a non-Xcode Python/py2app stack (frontier)
- Keyboard-only and Voice Control access to status items (frontier)
- Menu bar overflow notch hiding and user-disabled menu bar items (frontier)
- Menu versus popover versus window trade-offs for a network monitor (frontier)
- NSAccessibility.post announcements for status changes (frontier)
- NSDockTile badge for regular-policy menu bar apps (frontier)
- NSStatusItem removalAllowed KVO (frontier)
- NSStatusItem versus SwiftUI MenuBarExtra and activation policy LSUIElement and Dock tile (frontier)
- Notification authorization-denied UX in a menu-bar app (frontier)
- Notification categories and actions on macOS (frontier)
- PyObjC 12 and macOS 26 SDK bindings (frontier)
- Python PyObjC rumps py2app as a Mac App Store UI stack limits and native-shell options (frontier)
- Reduced Motion and Increase Contrast handling in menu bar icons (frontier)
- Settings scene workaround for accessory apps (frontier)
- Swift shell with embedded Python helper (XPC) (frontier)
- UNUserNotificationCenterDelegate willPresent for menu-bar apps (frontier)
- UserNotifications UNUserNotificationCenter migration from NSUserNotification (frontier)
- autosaveName position persistence (frontier)
- contentTintColor and badge/alert state icons (frontier)
- occlusionState detection of hidden status item (frontier)
macOS App Testing and Release QA
- App Store Connect API JWT key scoping (frontier)
- Build processing email failures (frontier)
- Clean-machine QA matrix VM fresh user latest macOS release and physical Mac (frontier)
- Container inspection and reset between test runs (frontier)
- Crash and log collection for store apps Organizer MetricKit OSLog and log collect versus zero telemetry (frontier)
- Entitlement assertion in CI smoke test (frontier)
- Export compliance ITSAppUsesNonExemptEncryption (frontier)
- First-launch and permission-prompt checks on clean installs (frontier)
- Fresh local user account on a physical Mac as clean state (frontier)
- ITMS-90889 provisioning profile for sandboxed Mac apps (frontier)
- Mac App Store signing certificate pairing (frontier)
- MenuBarExtra accessibility identifiers (frontier)
- MetricKit diagnostics in sandboxed Mac apps (frontier)
- Network fault injection for testing monitors Network Link Conditioner dummynet pfctl and DNS blackhole (frontier)
- Per-process fault injection via Network Extension (frontier)
- Privacy label wording for no-collection apps (frontier)
- QuickTime Player screen recording and trimming (frontier)
- Re-encoding a recording to H.264 with avconvert or ffmpeg (frontier)
- Reachability transition testing with NWPathMonitor (frontier)
- Sandbox verification harness sandboxed ad-hoc build sandbox-deny logs and container inspection (frontier)
- Screen recording for App Review capture tools codecs size and attach versus link (frontier)
- Snapshotting VM golden images with Tart (frontier)
- Symbolication with dSYMs for Organizer and MetricKit crashes (frontier)
- TestFlight Internal Only uploads (frontier)
- TestFlight for Mac internal and external testing build processing and beta review (frontier)
- UI automation of menu bar apps XCUITest and Accessibility API (frontier)
- Unified log capture via `log show` for after-the-fact deny analysis (frontier)
- Validate and upload altool Transporter App Store Connect API and ITMS error catalogue (frontier)
- automationmodetool and CI UI test setup (frontier)
- pf anchor lifecycle and pf.conf restoration (frontier)
Apple Platform Frontier for Mac Utilities
- App Privacy nutrition label data-type mapping for a DNS monitor (frontier)
- App Store Connect API and CLI automation of submission and review (frontier)
- Apple Business Manager custom apps and MDM distribution for IT audiences (frontier)
- Apple Business built-in MDM and Blueprints (frontier)
- Apple Foundation Models on-device diagnosis as an alternative to a cloud AI call (frontier)
- DDR/DNR resolver discovery and mDNSResponder behavior (frontier)
- Encrypted DNS DoH DoT system settings changes in macOS 26-27 (frontier)
- Foundation Models Evaluations framework (frontier)
- Guided generation with @Generable for structured diagnosis output (frontier)
- Individual vs team key CI policy (frontier)
- Location tokens and DDM app management (frontier)
- NEDNSProxyProvider vs encrypted DNS visibility (frontier)
- Privacy manifests PrivacyInfo.xcprivacy and required-reason APIs on macOS (frontier)
- Private Cloud Compute language model limits (frontier)
- Third-party SDK signature validation in Xcode (frontier)
- Unlisted app distribution (frontier)
- asc CLI command surface (frontier)
- fastlane deliver for macOS (frontier)
- macOS 26.1 profile install restrictions (frontier)
Mac App Store Readiness: Residual Gaps for Sandboxed Monitors
- App Privacy nutrition label entries for optional third-party AI (frontier)
- App Sandbox behavior of configd access (frontier)
- App Store Connect upload validation errors for embedded Python (ITMS-90238, ITMS-90338) (frontier)
- Apple TN3179 Local Network privacy (frontier)
- Apple nested code signing order and inherit entitlement for helper executables (frontier)
- BIS annual self-classification report for exempt mass-market encryption (frontier)
- BYO API key consent design and Notes for Review template for optional AI and alert features (frontier)
- Briefcase Xcode-format MAS submission (frontier)
- Debouncing event bursts before re-probing (frontier)
- French encryption declaration for App Store distribution (frontier)
- IPv6-only DNS64 NAT64 review network and IPv4-literal probes and Guideline 2.5.5 and Internet Sharing NAT64 testing (frontier)
- ITSAppUsesNonExemptEncryption Info.plist key and App Store Connect export compliance answers (frontier)
- Keychain storage of user-supplied API keys in a sandboxed app (frontier)
- NSLocalNetworkUsageDescription and NSBonjourServices in py2app Info.plist (frontier)
- NSXPCConnection codesign requirement validation (frontier)
- Network.framework NAT64 prefix discovery (nw_path) (frontier)
- Note 3 to Category 5 Part 2 mass market criteria (frontier)
- SCDynamicStore and NWPathMonitor event-driven change detection replacing fixed-interval probing (frontier)
- SCDynamicStore keys for DNS and proxies (frontier)
- SMAppService vs XPC service for helpers (frontier)
- Swift shell with embedded Python helper over XPC in a sandboxed app (frontier)
- XPC service entitlements and container access for Python helpers (frontier)
- arm64-only py2app builds (frontier)
- getaddrinfo AI_DEFAULT synthesis in Python socket (frontier)
- macOS 27 and 26 platform changes affecting sandboxed menu-bar network apps (frontier)
- py2app and Python packaging pipeline for the Mac App Store nested signing entitlements and slimming (frontier)
macOS Network Troubleshooting Tools and Diagnostics 12
Native Darwin network diagnostics: scutil, mDNSResponder, IP_BOUND_IF socket binding, networksetup ordering hazards, and sandbox ICMP limitations.
- Network Setup Service Ordering Hazards (frontier)
Darwin Packet Filter (PF) Anchor Lifecycle & Routing Inversion
Darwin packet filter architecture: pfctl anchor loading hierarchy, reference-counted token management (-E/-X), and evaluation order pitfalls.
- pfctl Reference Counted Tokens (frontier)
- com.apple Anchor Hierarchy (frontier)
- PF Ruleset Evaluation Order (frontier)
SystemConfiguration Dynamic Store Schema & RunLoop Notifications
Low-level SystemConfiguration architecture: Mach IPC message runloop sources, regex key pattern subscriptions, and state change debouncing.
- SCDynamicStore Session Management (frontier)
- State:/Network Key Hierarchy (frontier)
- Mach IPC Notification RunLoops (frontier)
NetworkExtension Userland DNS Proxy
Userland L7 DNS proxy provider using NEAppProxyUDPFlow/NEAppProxyTCPFlow for RFC 1035 inspection and encrypted transport forwarding without utun interfaces.
- NEAppProxyFlow Lifecycle (frontier)
- NEDNSSettingsManager Profile Activation (frontier)
- Content Filter Order Collision (frontier)
Darwin Network Multipath & Interface Failover Mechanics
Interface binding semantics on Darwin: IP_BOUND_IF vs POSIX bind, NWPathMonitor dynamic interface state tracking, and MPTCP kernel handover.
- IP_BOUND_IF Socket Option (frontier)
- NWPathMonitor Path Updates (frontier)
- Darwin MPTCP Sysctl (frontier)
Apple80211 and CoreWLAN TCC-Gated Diagnostics
CoreWLAN diagnostic boundaries on macOS 14/15: private Apple80211 airport binary removal, TCC location gating on SSID/BSSID, and headless CLI limitations.
- CoreWLAN CWInterface API (frontier)
- TCC Location Authorization Gate (frontier)
- Airport CLI Deprecation (frontier)
- ICMP Rate Limiting and Fallback Corroboration (frontier)
Apple Unified Logging Architecture for Network Observability
Unified logging (os_log) diagnostics for macOS networking: com.apple.network and mDNSResponder subsystems, %{public}s privacy redaction, and sandbox log boundaries.
- os_log Subsystem Filtering (frontier)
- %{public}s Privacy Masking (frontier)
- Sandbox In-Memory Ring Buffer Logging (frontier)
- SystemConfiguration and mDNSResponder Mach IPC (frontier)
Darwin Interface Queue Metrics & Bufferbloat Triage
Measuring interface queue latency and bufferbloat on Darwin: netstat error counters, FQ-CoDel active queue management, and networkQuality RFC 9040 RPM metrics.
- netstat -ibn Queue Metrics (frontier)
- Darwin Kernel FQ-CoDel (frontier)
- RFC 9040 Responsiveness RPM (frontier)
Captive Portal and iCloud Private Relay Interception
Captive portal detection via CNA canary probes (captive.apple.com) and dual-hop MASQUE HTTP/3 Private Relay ingress with enterprise DNS canary suppression.
- CNA Hotspot Probe Architecture (frontier)
- iCloud Private Relay MASQUE Protocol (frontier)
- Enterprise Split-DNS Canary (mask.icloud.com) (frontier)
Encrypted DNS Transport Diagnostics (DoH, DoT, DoQ, DDR)
Modern encrypted DNS transports on macOS: Discovery of Designated Resolvers (DDR), SVCB/HTTPS resource records, and ECH handshake privacy diagnostics.
- RFC 9462 DDR Discovery (frontier)
- RFC 9460 SVCB DNS Records (frontier)
- TLS 1.3 Encrypted Client Hello (frontier)
App Store Sandbox Subprocess Spawning & Seatbelt Policy
Subprocess execution rules under macOS App Sandbox: posix_spawn seatbelt profile inheritance, allowable diagnostic binaries (/sbin/ping, scutil), and rejection 2.1 remedies.
- posix_spawn Seatbelt Inheritance (frontier)
- Allowable Diagnostic Binaries (frontier)
- Guideline 2.1 Rejection Remedy (frontier)
AppKit Asynchronous RunLoop Networking & Zero-Wait UI
Ensuring 60Hz/120Hz ProMotion UI responsiveness in macOS menu-bar apps: avoiding blocking Mach IPC getaddrinfo on main thread, GCD thread starvation, and timer patterns.
- Main RunLoop Thread Isolation (frontier)
- DispatchSourceTimer Precision (frontier)
- GCD Worker Thread Starvation (frontier)
Local Network Privacy Mechanics (macOS 15+ TCC)
Local Network Privacy in macOS 15 Sequoia: TCC gating of RFC 1918 unicast, multicast mDNS, and broadcast packets, with headless CLI silent failure modes.
- DTS TN3179 Architecture (frontier)
- RFC 1918 Unicast TCC Enforcement (frontier)
- Bonjour Multicast Gating (frontier)
- Darwin Socket Pinning and IP_BOUND_IF (frontier)
Sleep/wake, DarkWake and App Nap handling for polling network monitors
- DarkWake detection through IOPMrootDomain interest notifications (IOServiceAddInterestNotification, CurrentPowerState ke (frontier)
- NSWorkspaceScreensDidSleep/Wake versus system sleep, and what a desktop Mac sends (frontier)
- XPC Activity (XPC_ACTIVITY_REQUIRE_SCREEN_SLEEP) as a maintenance-wake proxy (frontier)
- NSSystemClockDidChangeNotification and wall-clock steps (NTP, timezone) for the wall-clock users (frontier)
- NWPathMonitor "satisfied but DNS false" transitions and the 8 s unsatisfied flip, on macOS (frontier)
- SCDynamicStore State:/Network/Global/IPv4 as an event to end the settle window early (frontier)
- TCP keepalive offload (TKO) and preferred-network offload (PFN) wake reasons in the power log (frontier)
- Wake for network access (womp), Bonjour Sleep Proxy, and networkoversleep (frontier)
- Captive-portal detection after wake (captive.apple.com) misread as NETWORK failure (frontier)
- getaddrinfo EAI_AGAIN versus EAI_NONAME as a tri-state for the DNS reading (frontier)
- Stale resolver or split-DNS cache after wake with VPN (tailscale, netbird), and a dscacheutil flush that is only partial (frontier)
- com.apple.powerd:sleepWake unified-log category as an in-sandbox sleep history source (unified log is off in the store b (frontier)
- Local Network privacy prompt timing at first launch or first wake (macOS 27) (frontier)
- Activity Monitor "App Nap" column and NSApplicationDidChangeOcclusionStateNotification for occlusion-aware polling (frontier)
- py2app launch ordering at login versus Wi-Fi readiness (SMAppService login item in a store build) (frontier)
- Critical Dock bounce (NSCriticalRequest) persistence after a false ping alert (frontier)
- NSActivityLatencyCritical cost for a 5 s heartbeat (frontier)
- Reset-on-wake semantics for a re-armed alert_repeat_seconds timer (frontier)
Mach-O SDK stamp and the macOS 26 SDK upload requirement (ITMS-90725)
- App Store Connect e-mailed warning catalogue for macOS uploads (ITMS-9xxxx) and which ones block versus advise (frontier)
- Transporter and altool validation output for a macOS .pkg: reading the processing log for build 4 (frontier)
- CFBundleSupportedPlatforms and DT keys: exactly which App Store Connect checks read them (frontier)
- Linked-on-or-after gates a Python launcher inherits at SDK 27: hidden menu item images, Liquid Glass, UIDesignRequiresCo (frontier)
- Dyld SDK APIs (dyld_program_sdk_at_least, dyld_image_sdk_at_least) and whether nested images' stamps matter at runtime (frontier)
- Rebuilding PyPI native wheels (--no-binary) against the current SDK for a store bundle: cost and reproducibility (frontier)
- Thin-to-arm64 pass (lipo -thin) for universal2 pyobjc and charset_normalizer extensions in a store bundle (frontier)
- vtool -set-build-version plus codesign inside-out re-sign order for nested libraries (frontier)
- Beta-host-OS and beta-SDK detection heuristics: Apple build-number patterns (3-digit release, 4-digit seed) (frontier)
- Product Definition Property List and Distribution allowed-os-versions / hostArchitectures from productbuild (frontier)
- ITMS-90264 minimum-system-version mismatch behaviour with LSMinimumSystemVersion and the Distribution file (frontier)
- Xcode-to-SDK map for upload eligibility: 26.x to macOS 26.x SDK, 26.6 to SDK 26.5, 27.0 GA, 27.1 beta iOS-only (frontier)
- python.org universal2 installer as a store-bundle base: Tcl/Tk, minos 10.15/11.0, and tkinter's ITMS-90338 history (frontier)
- py2app stub rebuild (apptemplate/setup.py) as an upstream contribution or a pinned local patch (frontier)
- Mac App Store processing e-mails versus App Store Connect "Activity" tab for build rejection reasons (frontier)
- App Review's macOS 27.2 seed: which OS build reviewers run and how to reproduce it (frontier)
Keychain in the sandboxed Mac App Store release build
- Data-protection keychain access groups on macOS (keychain-access-groups, com.apple.application-identifier, wildcard prof (frontier)
- Designated requirement of App Store re-signed vs TestFlight re-signed Mac apps (marker OIDs 6.1.9 vs 6.1.25.1) (frontier)
- SecItem shim routing (SecItemCategorizeQuery) and result merging, per macOS release (frontier)
- Non-interactive file-based keychain reads without SecKeychainSetUserInteractionAllowed (frontier)
- macOS 26.4+ login keychain data protection and /var/db/SystemKeys entropy files (effect on stored API keys after restore (frontier)
- errSecAuthFailed -25293 after an OS upgrade for early-startup reads (FB22448572) (frontier)
- kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly behaviour on a locked or asleep Mac for background reads (frontier)
- SecTaskCopyValueForEntitlement as a runtime capability probe inside the App Sandbox (frontier)
- TestFlight Mac signing and profile behaviour (ITMS-90889, DR change on promotion to App Store) (frontier)
- Provisioning profile expiry (2027-09-27) and what an installed App Store app keeps after the profile is stripped (frontier)
- Keychain item lifecycle on app deletion and the "Remove credentials" promise in the privacy policy (frontier)
- Reviewer VM image state: auto-login, locked or missing login keychain at first launch (frontier)
- App Review static scan versus deprecated public Security symbols loaded through PyObjC (frontier)
- Keychain Access display of DP "Local Items" and user-facing removal instructions (frontier)
- Per-item SecAccessControl with biometrics for API keys: benefit versus complexity for a menu-bar monitor (frontier)
- Notes for Review wording for optional Keychain-stored credentials and the App Privacy label (frontier)
Guide-don't-fix remediation UX with System Settings deep links
- System Settings anchor discovery by reading ExtensionKit revealElementForKey: strings per macOS release (frontier)
- x-help-action://openPrefPane versus x-apple.systempreferences equivalence (frontier)
- Privacy_LocalNetwork anchor and the Local Network prompt for peer discovery (macOS 26/27) (frontier)
- Required-reason API manifest entries for NSWorkspace open and NSPasteboard writes (frontier)
- Notification settings deep link by bundle ID (com.apple.Notifications-Settings.extension?id=) (frontier)
- Wireless Diagnostics and Wi-Fi Recommendations as hand-off targets from a sandboxed utility (frontier)
- Report-reading UX for App Review: where the reviewer looks first and in what order (frontier)
- Display-only root commands: guideline reading of 2.4.5(v) versus app-driven sudo (frontier)
- NSWorkspace.openURL_ return semantics for registered-scheme handlers that land on the wrong pane (frontier)
- Localized hint text and Apple's localized help wording for the macOS 27 Network pane (frontier)
- Device Management and DNS configuration profiles as a hidden cause of DNS faults (encrypted DNS payloads) (frontier)
- Pasteboard write-only "copy command" patterns and macOS 15.4+ pasteboard privacy (frontier)
- Dormant-feature disclosure for switched-off code under 2.3.1(a) in a dual-edition bundle (frontier)
- NetCheck-style network path diagram (Mac, router, internet) as a read-only substitute for repair (frontier)
- Settings drift checking across macOS 26.x and 27.x betas (new, renamed or removed panes such as Screen Saver) (frontier)
- Apple Support article 102281 (VPN and security software network issues) as a hand-off link (frontier)
Sandbox report export via NSSavePanel and user-selected files
- Powerbox open-and-save panel XPC service (com.apple.appkit.xpc.openAndSavePanelService): lifecycle, dismissal, and how A (frontier)
- App-data prompt when a receiving app opens a file from another app's container ("would like to access data from other ap (frontier)
- NSAppDataUsageDescription (listed in Apple's App Sandbox topics): meaning, when macOS shows it, whether this app needs i (frontier)
- NSFilePromiseProvider drag-out of a report from the dashboard window under the sandbox (frontier)
- NSSharingService Mail compose with a container file attachment: actual result and the review-demo path (frontier)
- Quick Look preview extension for .md/.json incident reports (QLPreviewingController in a sandboxed app) (frontier)
- Custom document type or exported UTI for report files (UTExportedTypeDeclarations, CFBundleDocumentTypes, LSHandlerRank) (frontier)
- PDF or HTML report rendering through NSPrintOperation or WKWebView.createPDF and the com.apple.security.print entitlemen (frontier)
- NSApplication.activate() migration across the six activateIgnoringOtherApps_ call sites (frontier)
- rumps timer behaviour during runModal versus begin(completionHandler:) (NSTimer run-loop modes) (frontier)
- PyObjC block handlers for beginWithCompletionHandler_ and main-thread guarantees (frontier)
- On-demand "diagnosis report" for a healthy network: honest wording that is not an incident and claims no repair (frontier)
- Redaction coverage beyond sensitive_strings: IPv4/IPv6, MAC, SSID and hostname patterns in scutil --dns, netstat -rn and (frontier)
- Reports retention and pruning inside the container (disk growth with a .json and .md pair per incident) (frontier)
- NSIsRelatedItemType related-file access for exporting the .md/.json pair from one Save panel (frontier)
- Clean-VM validation of default handlers (.md, .html, mailto:) on stock macOS 27.2 and the kLSApplicationNotFoundErr path (frontier)
- UTType.markdown (macOS 27.0) and when CoreTypes first declared net.daringfireball.markdown (frontier)
- Finder visibility of ~/Library/Containers for non-technical reviewers and IT staff (Go to Folder, Option key, chflags no (frontier)
- Default mail client variance (mailto: handler is a browser here) for any "Email report to IT" feature (frontier)
- Guideline 2.5.2 wording versus user-selected exports: what App Review accepts (frontier)
Donation links, Guidelines 3.1.1 and DSA trader status
- Support-URL page link audit: every link reachable in two clicks from each Apple-reviewed URL (frontier)
- GitHub FUNDING.yml validity rules and Sponsors enrollment (frontier)
- Guideline 3.2.1(vii) individual-to-individual gift versus developer tips (frontier)
- IAP tip jar set-up: consumable product, Paid Applications Agreement, tax forms (frontier)
- US storefront anti-steering rules as applied to Mac App Review (frontier)
- EU DMA link-out commissions effective October 1, 2026 and the under-13 link-out ban (frontier)
- DSA Article 30 best-efforts verification and what Apple checks for non-traders (frontier)
- Commission UCPD Notice 2021/C 526/01 Section 2.2 concept of trader (frontier)
- EC Influencer Legal Hub trader brief and creator-monetisation test (frontier)
- Cyber Resilience Act commercial-activity test for free open-source apps (Reg. 2024/2847 recital 15) (frontier)
- DAC7 reporting entries in App Store Connect for free-app developers (frontier)
- Labels and Markings URL for traders (frontier)
- P.O. Box and mail-forwarding address as the displayed trader address (frontier)
- GA4 on the app's privacy-policy page versus "no analytics" and the App Privacy label (frontier)
- Notes for Review wording for payment and donation questions (frontier)
- Public repo plus store build: non-store "full edition" mentions and Guideline 2.3.10 (frontier)
- Per-app trader override in App Information > App Store Regulations and Permits (frontier)
- Apple forum access when verify-human blocks agents (alternatives: archived copies, Apple Developer app) (frontier)
- Apple Developer Program License Agreement wording on the DSA declaration (frontier)
- About panel presence in a rumps/py2app Dock app with a custom main menu (frontier)
App Review off-binary surface: Support and Privacy URL audit
- In-app Help and Support menu item plus standard About panel for a Dock menu-bar app (rumps, PyObjC) (frontier)
- Apple App Privacy "web traffic" rule when a policy opens in WKWebView or SFSafariViewController (frontier)
- Reviewer-visit telemetry: Cloudflare zone analytics by ASN 714 for a review window (frontier)
- Cloudflare Email Address Obfuscation against contact-information checks on a Support URL (frontier)
- Soft-404 single-page fallback on Cloudflare Pages and why a 200 status proves nothing about a URL (frontier)
- Policy-versus-label wording: "collect", "receive", "share" and the third-party-partner definition for a bundled API SDK (frontier)
- 5.1.1(i) equal-protection confirmation wording for a bring-your-own-key AI provider (frontier)
- Optional Privacy Choices URL (App Store Connect) for a no-account app (frontier)
- Per-locale Support and Privacy URLs in App Store Connect (frontier)
- SBOM on the support site (Apple note) and the EU Cyber Resilience Act for bundled Python dependencies (frontier)
- GA4 consent mode and ePrivacy for the host site's EU visitors (frontier)
- Store-bundle strings for sudoers and privilege code against Guideline 2.4.5 static scans (frontier)
- Public repo as a reviewed surface: README scoping for a dual-edition project (frontier)
- First-party WebMCP bridge scripts on pages Apple may open (frontier)
- Trader-declaration contact parity: product-page address and phone against the Support page (frontier)
- Reopen-main-window menu rule for macOS Dock apps (Guideline 4) against Open Dashboard (frontier)
- Release-build URL gate design: injected fetcher, distinctive-string check, offline tests (frontier)
Tri-state probe results, captive portal and DarkWake in the sandbox
- Fake-IP and split-DNS resolvers (benchmark and CGNAT ranges, Tailscale MagicDNS, WARP, Surge) answering public names w (frontier)
- Tunnel-interface (utun) route changes as a likely real source of "TCP down, DNS up" on this Mac (one incident examined) (frontier)
- kIOPMMessageUserIsActiveChanged and IOPMUserIsActive as a full-wake signal (frontier)
- Delivering an SCDynamicStore callback through ctypes on the rumps main run loop (frontier)
- Reading State:/Network/Service/<id>/DHCP Option_114 and DHCPv6 option 103 as a portal hint (frontier)
- RFC 8908 API fetch: certificate validation, seconds-remaining and can-extend-session handling (frontier)
- captive.apple.com allow-listed networks (walled gardens that make Apple's probe pass while the Internet is blocked) (frontier)
- ICMP-only failure display ("ping blocked") versus a network failure in menu-bar copy (frontier)
- ping -6/ping6 behaviour and ICMPv6 heartbeat on a NAT64 network (frontier)
- NAT64 prefix discovery through ipv4only.arpa and nw_nat64_ for the interface prober (frontier)
- Unified-log symptomsd "DNS failure tell health status" lines as corroboration (not available in the sandbox) (frontier)
- Local Network permission errno for BSD connect() and for a spawned /sbin/ping (frontier)
- App Review reading of captive.apple.com traffic in the privacy label and notes (frontier)
- UnicodeError/idna edge cases in user-entered hostnames (IDN, trailing dot, zero-width characters; example.com resolved (frontier)
- Resolver cache hits that make dns_ok True during an outage (mDNSResponder negative and positive TTLs) (frontier)
- NWPathMonitor through ctypes or a Swift helper versus polling scutil --nwi (frontier)
Reviewer first-launch environment, Keychain state and signing facts
- Attribute-only Keychain presence checks (kSecReturnAttributes) versus data reads: which calls need ACL or unlock authori (frontier)
- securityd unlock queries and the client "user interaction allowed" flag: why the flag did not reach the unlock path (frontier)
- SecurityAgent dialogs left behind by dead clients: respawn behaviour and safe cleanup in tests (frontier)
- Fresh macOS account and VM first-login Keychain creation (loginwindow, sysadminctl, auto-login images) (frontier)
- Data-protection keychain read and add inside a TestFlight-delivered Mac sandbox (frontier)
- Gatekeeper and AMFI behaviour for a locally installed Apple Distribution app with a Mac App Store profile and no receipt (frontier)
- TestFlight internal testing for Mac builds: first-launch dialogs, 90-day expiry, signing identity (frontier)
- App Store Connect builds and buildUploads REST resources: processingState, buildProcessingState, qcState, processingErro (frontier)
- Transporter 1.4.5 log layout and the swinfo package analysis step (frontier)
- altool --build-status and --output-format json for a CI-style upload gate (frontier)
- App Review reviewer device OS: public release versus seed, and how rejection messages report it (frontier)
- 2.4.5(viii) and 2.5.1 enforcement on deprecated public Security symbols versus removed frameworks (frontier)
- Python text and .pyc string scanning by the App Store upload scan (itms-services precedent) (frontier)
- Required-reason API privacy manifests for macOS bundles (scope text names only iOS, iPadOS, tvOS, visionOS, watchOS) (frontier)
- Build-path and username leakage in py2app PythonInfoDict (frontier)
- Lazy credential reads behind a consent gate in a store build (5.1.2(i)) (frontier)
Store bundle static scan, dormant code and Local Network prompt triggers
- Staged-source build: run py2app on a pruned copy of the package instead of deleting afterwards (frontier)
- Clean-venv reproducible py2app build and a "no unexpected distributions" gate (mcp contamination) (frontier)
- What runs at upload (altool/Transporter validation) versus at review (string and symbol scans): a timeline per guideline (frontier)
- Observing Local Network decisions: nehelper and mDNSResponder log predicates, fresh-account and VM procedures (frontier)
- Responsible-process attribution for setuid children (/sbin/ping) under App Sandbox and Local Network privacy (frontier)
- ICMP and Local Network privacy: does ICMP echo to an on-link host count? (frontier)
- com.apple.network.local-network allow-list defaults (AllowedWiFiLocalNetworkAddresses) for review-network testing (frontier)
- network.server justification patterns when the listener is user-enabled (2.4.5(i) precedents) (frontier)
- Purpose-string review under 5.1.1(ii): wording for conditional features (frontier)
- Splitting privileges.py into constants and actions so the actions can be omitted (Tier 2) (frontier)
- Splitting failover.py into read-only listing and write path (Tier 3) (frontier)
- py2app recipes that force packages in (detect_dunder_file) and how to override them (frontier)
- Source versus bytecode versus zip for first-party code: visibility to reviewers and scanners (frontier)
- Notes for Review dormant-feature disclosure patterns and a template library (frontier)
- Info.plist hygiene for py2app builds (PythonInfoDict developer path, NSAppleScriptEnabled) (frontier)
- Executable data files inside stdlib packages (fetch_macholib) and bundle-wide executable audit (frontier)
- Interaction of the Local Network prompt with the screen-recording demo script (timer fire date, restart-only settings) (frontier)
Pre-upload gate suite and TestFlight-first verification plan
- TestFlight-only diagnostic build numbering (non-contiguous builds, "Internal Only" uploads) (frontier)
- TestFlight Beta Distribution certificate chain and the 25.1 marker OID across macOS releases (frontier)
- Data-protection keychain probe inside a store-signed sandbox (in-app entitlement probe design) (frontier)
- Profile expiry behaviour of an installed TestFlight Mac app after the profile lapses (frontier)
- App Store Connect REST API build-status polling as a post-upload gate (builds and buildBetas) (frontier)
- Gate ratchet baselines: string, entitlement and Mach-O set diffs against the last accepted build (frontier)
- Reproducible py2app bundles: dirty-tree detection and deterministic bundle hashes (frontier)
- Cloudflare Web Analytics injection rules and what a reviewer's Safari sees (frontier)
- Static vs DOM-rendered page audits for App Review surfaces (frontier)
- NAT64 test harness on a second Mac (Internet Sharing "Create NAT64 Network") for T10 (frontier)
- Wake and lid-close test protocol for menu-bar monitors (frontier)
- NSUserNotificationCenter on macOS 27.x under the sandbox and the UNUserNotificationCenter migration cost (frontier)
- Release-engineering ledger for uploads made from several machines (frontier)
- Docs-drift rules as a lint: fact sources, ignore markers, false-positive budget (frontier)
- Reviewer-device string capture from the rejection message (frontier)
- Second-user and VM-free "fresh machine" protocol for macOS release QA (frontier)
Writing and Documentation ● 67
Document Critique ● 1
14-pass review methodology ●
- Severity scale (Blocking / Major / Medium / Minor / Nit) (frontier)
- Convergence loop with 3-iteration cap (frontier)
- Adversarial injection and hallucination guard (frontier)
- Meta-artifact and versioning cleanup (frontier)
- Human-voice rephrasing pass (frontier)
- Authoritative verification and fact-checking (frontier)
- Domain-aware skill activation (frontier)
Draft Review Revise Loop ● 1
24-hour cooling-off rule ●
- Shitty first draft (Lamott) (frontier)
- Named-framework review (BLUF, MECE, Minto, SCQA) (frontier)
- Severity-ranked findings (Critical / High / Medium / Low) (frontier)
- Hard stop (3 iterations) (frontier)
- Soft stop (no medium-or-higher findings) (frontier)
- Convergence stop (5% word-count delta) (frontier)
- Time-box stop (50% draft effort) (frontier)
- Fresh eyes pattern (frontier)
- Bail conditions (scope / audience / premise changed) (frontier)
Editing and Revision ●
- Four editing types (developmental, line, copy, proofreading) (frontier)
- Multi-pass top-down methodology (structural → paragraph → sentence → word) (frontier)
- Nominalization elimination (Williams) (frontier)
- Given/New contract (Williams) (frontier)
- Verb-first pass (frontier)
- Active-voice scan (frontier)
- Cut-30% pass (frontier)
- Paragraph-coherence pass (frontier)
- Topic-sentence-first pass (frontier)
Doc Archaeology ●
- Five decay categories (stale facts, dead links, drift, phantom dependencies, obsolete examples) (frontier)
- Last-updated lens pass (frontier)
- Link verification pass (frontier)
- Process-currency pass (frontier)
- Dependency audit pass (frontier)
- Example validation pass (frontier)
- Salvage decision (update / restructure / deprecate / archive / delete) (frontier)
- Semantic decay and knowledge drift (frontier)
- Diátaxis process-drift theory (how-to guides rot fastest) (frontier)
- Nielsen documentation maintenance research (frontier)
Offer Design and Value Proposition ●
- Value Proposition Canvas (frontier)
- Jobs-to-Be-Done (frontier)
- Positioning Strategy (frontier)
- Offer Stack Design (frontier)
- Guarantee Design (frontier)
- Ethical Scarcity and Urgency (frontier)
- Category Design (frontier)
- Price Anchoring in Offers (frontier)
- Message-Market Fit (frontier)
- Objection Handling Architecture (frontier)
AI-Assisted Copywriting Workflow ●
- Brand-Voice Prompting System (frontier)
- Copy Brief Template (frontier)
- Human-in-the-Loop Copy QA (frontier)
- Variation Generation at Scale (frontier)
- AI Copy Failure Modes (frontier)
- FTC Compliance for AI Content (frontier)
- Instruction Drift Mitigation (frontier)
- Awareness-Stage Copy Prompting (frontier)
Conversion Copywriting and Voice of Customer ●
- VOC Research (frontier)
- Review Mining (frontier)
- JTBD Message Extraction (frontier)
- Message Hierarchy (frontier)
- Post-Purchase Survey Design (frontier)
- Stages of Awareness Research (frontier)
- Copy Testing (frontier)
Runbook Craft ●
- The fresh-machine test (frontier)
- Atomic numbered steps with verb-first imperatives (frontier)
- You-are-here markers and progress anchoring (frontier)
- Prerequisites block at the top (frontier)
- Rollback as a first-class section (frontier)
- Decision points with measurable thresholds (frontier)
- Post-condition checks (assertions) (frontier)
- Ownership, review cadence, and metadata (frontier)
- Copy-pasteable commands and no placeholders in prose (frontier)
- Common runbook anti-patterns (frontier)
Incident Comms 1
What-we-know / what-we-are-doing / next-update-at triple ●
- Heartbeat rule and predictable cadence (frontier)
- Voice shifts across the incident timeline (hour zero to resolution) (frontier)
- Internal vs external surfaces separation (frontier)
- No speculation no causes until confirmed (frontier)
- Quantified impact not vague gestures (frontier)
- Apology calibration (specific, late, owned) (frontier)
- Designated voice and single source of truth (frontier)
- Subscribe affordance and the silent audience (frontier)
- All-clear has a checklist not just a message (frontier)
Postmortem Writing ●
- Blameless framing in prose (system not human) (frontier)
- Timeline reconstruction in UTC with source-of-truth (frontier)
- Contributing factors vs root cause distinction (frontier)
- Five Whys discipline (not literally five, never one) (frontier)
- Action items with owners, dates, severity, traceability (frontier)
- What went well without performative positivity (frontier)
- Hindsight bias and the linguistic markers to delete (frontier)
- Customer impact section (quantified, time-bounded, honest) (frontier)
- Publication and review ritual (frontier)
- Sensitive incidents (security, privacy, legal review) (frontier)
Error Message Craft ●
- The what / why / what-to-do-next triple (frontier)
- No-blame language (system owns the failure) (frontier)
- User terms vs internal terms (frontier)
- Error code conventions and status-code-vs-error-code distinction (frontier)
- Concrete next action or admit there is none (frontier)
- Conservative punctuation (exclamation marks, ALL CAPS, ellipses) (frontier)
- Internationalization (pluralization, register, length budget) (frontier)
- NN/g hostile patterns to avoid (frontier)
- Form-validation errors (inline, contextual, specific) (frontier)
- Separate user-facing string from log string with correlation IDs (frontier)
Commit Message Craft ●
- Conventional Commits (frontier)
- Tim Pope 50/72 rule (frontier)
- Imperative-mood subjects (frontier)
- BREAKING CHANGE footer (frontier)
- Why-not-what body discipline (frontier)
- Fixup/squash/autosquash workflow (frontier)
- Signed-off-by/DCO trailers (frontier)
- Co-authored-by trailer (frontier)
- Multi-commit storytelling (frontier)
- Commit splitting heuristics (frontier)
Pull Request Description Craft ●
- WWHT template (What/Why/How/Test) (frontier)
- Two-tier reader pattern (skimmers vs nit-pickers) (frontier)
- Before/after screenshots and recordings (frontier)
- Link-out vs inline detail (frontier)
- Reviewer shopping and CODEOWNERS (frontier)
- Draft/blocked/stacked signaling (frontier)
- Stacked PR workflow (frontier)
- Verifiable PR checklists (frontier)
- PR title as squash-commit subject (frontier)
- Conventional Comments for review threads (frontier)
API Documentation Craft ● 1
10-minute Getting Started tutorial ●
- Diátaxis four-quadrant framework (Procida) (frontier)
- Endpoint reference page structure (frontier)
- Multi-language code samples (frontier)
- Error catalog pattern (frontier)
- RFC 8594 Sunset/Deprecation headers (frontier)
- URI vs header vs date-pinned versioning (frontier)
- OpenAPI/Swagger three-pane layout (frontier)
- Try It interactive widgets (frontier)
- Explanation quadrant essays (frontier)
Proposal and Grant Writing ●
- Problem Statement (frontier)
- Demonstrated Need (frontier)
- Theory of Change (frontier)
- Logical Framework (Logframe) (frontier)
- SMART Objectives (frontier)
- NIH Specific Aims (frontier)
- Budget Narrative (frontier)
- Sustainability Plan (frontier)
- Executive Summary (frontier)
- Attachments Hygiene (frontier)
Resume and CV Writing ●
- X-Y-Z Achievement Formula (frontier)
- Quantification Discipline (frontier)
- ATS Parse-Friendly Formatting (frontier)
- Role Tailoring (frontier)
- Cover Letter Complement (frontier)
- Skills Section Debate (frontier)
- LinkedIn vs Resume Tone (frontier)
- Academic CV vs Industry Resume (frontier)
- Employment Gap Explanation (frontier)
- Senior IC vs Management Track (frontier)
- Portfolio vs Resume Convention (frontier)
Policy and Governance Writing ●
- RFC 2119 / RFC 8174 normative keywords (frontier)
- NIST SP 800-12 policy hierarchy (frontier)
- Policy components (scope, definitions, roles, exceptions, review) (frontier)
- ISO/IEC 27001 Annex A policy patterns (frontier)
- Plain Writing Act 2010 accessibility (frontier)
- Exception clauses (frontier)
- Change management and version control (frontier)
- Policy vs RFC vs ADR vs runbook distinction (frontier)
Academic and Citation Writing ●
- APA 7th edition citation style (frontier)
- Chicago Manual of Style 17th edition (notes-bibliography and author-date) (frontier)
- MLA 9th edition core-elements template (frontier)
- IEEE and Vancouver numeric citation systems (frontier)
- Signal phrases and source integration (frontier)
- Pseudo-citation avoidance (frontier)
- Primary vs secondary vs tertiary sources (frontier)
- Persistent identifiers (DOI, ORCID, ISBN) (frontier)
- Reference management tools (Zotero, BibTeX) (frontier)
- Toulmin argument structure (frontier)
- Literature review funnel pattern (frontier)
- Abstract vs introduction distinction (frontier)
Support Ticket Writing ●
- First-Response Templates (frontier)
- HEARD De-escalation (frontier)
- ASAP De-escalation (frontier)
- Holding Statement Patterns (frontier)
- Apology Calibration (frontier)
- Status-Update Cadence by Severity (frontier)
- Warm vs Cold Handoff (frontier)
- Phone vs Ticket Decision (frontier)
- CSAT and Closing Language (frontier)
Microcopy and UI Writing ●
- Verb-the-Noun Button Rule (frontier)
- Empty State Copy (frontier)
- Error and Validation Messages (frontier)
- Confirmation Dialogs (frontier)
- Toast and Modal Patterns (frontier)
- Sentence vs Title Case (frontier)
- Onboarding and Password-Reset Flows (frontier)
- Dark Pattern Avoidance (frontier)
- Mailchimp/Polaris/HIG/Material/GOV.UK Conventions (frontier)
Diátaxis Tutorial Quadrant ●
- Backward design (frontier)
- Cognitive load 7±2 (frontier)
- Narrator voice (frontier)
- Learner's promise (frontier)
- Carpentries pedagogy (frontier)
Diátaxis How-To Quadrant ●
- Prerequisite blocks (frontier)
- Imperative steps (frontier)
- Cookbook conventions (frontier)
- Branching guides (frontier)
- How-to vs tutorial (frontier)
Diátaxis Reference Quadrant ●
- Parameter tables (frontier)
- Exhaustive coverage (frontier)
- No-surprises rule (frontier)
- Structure-mirrors-product (frontier)
- Search-discoverability (frontier)
Diátaxis Explanation Quadrant ●
- Mental-model construction (frontier)
- ADR pattern (frontier)
- Decisions log (frontier)
- Alternatives considered (frontier)
- Discussion vs RFC vs runbook (frontier)
Press Release Writing ●
Crisis PR Writing ●
Whitepaper Writing ●
Case Study Writing ●
Cover Letter Writing ●
Job Description Writing ●
Performance Review Writing ●
PRD Writing ●
- Problem-first structure (Lenny) (frontier)
- Cagan four-section minimum (frontier)
- MVP vs v1 vs roadmap scoping (frontier)
- Shape Up pitch (Basecamp) (frontier)
- Wireframes vs prose (frontier)
- Leading vs lagging metrics (frontier)
- Stakeholder sign-off pattern (frontier)
- Non-goals as first-class section (frontier)
- Designed-by-committee anti-pattern (frontier)
Pitch Deck Writing ● 1
10/20/30 rule (Kawasaki) ●
- Sequoia / Reid Hoffman structure (frontier)
- Y Combinator seed deck (frontier)
- Narrative arc (problem-solution-traction-team-ask) (frontier)
- Appendix slide convention (frontier)
- What I most want you to remember closer (frontier)
- No-cliffhanger rule (frontier)
- Narrative deck vs traditional deck (frontier)
- Designer + writer collaboration (frontier)
- Slide title as thesis (frontier)
Survey Question Writing ●
- Likert scale design (frontier)
- NPS / CSAT / CES choice (frontier)
- Question-stem hygiene (Dillman) (frontier)
- Agree-disagree anti-pattern (Saris & Gallhofer) (frontier)
- Double-barreled and leading question detection (frontier)
- Anchor labels and ordering effects (frontier)
- Mobile survey constraints (frontier)
NPS Response Writing ●
Meeting Minutes and Decision Log ●
OKR Writing ●
Email Craft ●
- Subject Line Discipline (frontier)
- BLUF Opening (frontier)
- One Ask Per Email (frontier)
- Reply-All Etiquette (frontier)
- Follow-Up Cadence (frontier)
- Breakup Email (frontier)
- Cold Outreach (Non-Sales) (frontier)
- Intro Request and Double Opt-In (frontier)
- Thank-You Notes (frontier)
- Send-Time Decisions (frontier)
- Phone vs Email Judgment (frontier)
- Slack vs Email Test (frontier)
- Signature Hygiene (frontier)
- Attachment vs Link (frontier)
- Email Tone and Register (frontier)
One-Pager Writing ●
- No-Second-Page Discipline (frontier)
- Above-the-Fold Visual Hierarchy (frontier)
- Headline + Value-Prop Pattern (frontier)
- If You Only Read One Line (frontier)
- Amazon 1-Pager and PR-FAQ (frontier)
- Working Backwards Lineage (frontier)
- Bullets vs Paragraphs (frontier)
- Section Budget for One Page (frontier)
- Design vs Writing Collaboration (frontier)
- Account Brief Species (frontier)
- Project Pitch Species (frontier)
- Sales-Enablement One-Pager Species (frontier)
AI Collaboration Writing ● 1
Prompt-side control of LLM lexical tics
- Auditing the vocabulary of system prompts and instruction files (frontier)
- Base vs instruct repetition behaviour (frontier)
- Context-borne lexical contagion (frontier)
- Decoding-time suppression as alternative to prompt lists (frontier)
- Exemplar diversity and unintended pattern pickup (frontier)
- Few-shot exemplars versus banned-word lists for style control (frontier)
- Formatting mirroring (frontier)
- Ironic rebound mechanism in attention heads (frontier)
- Linting instruction files for emphatic language (frontier)
- Negative-instruction backfire in style prompts (frontier)
- Positive substitution style guides (frontier)
- Prohibition plus named replacement (frontier)
- Prompt style matching output style (frontier)
- Prompt-format mirroring in output (frontier)
- Structural priming in generation (frontier)
- Voice descriptions versus wording lists (frontier)
- Four Workflow Modes (I-draft/AI-edits, AI-drafts/I-edit, style-sample prompting, redline-not-rewrite) (frontier)
- Voice Transfer Problem (frontier)
- Few-Shot Style-Sample Prompting (frontier)
- AI Disclosure Ethics 2026 (frontier)
- FTC and New York 2026 Disclosure Rules (frontier)
- Prompt-Style-Guide Artifacts (frontier)
Accessibility Writing ●
- Heading Structure (H1-H2-H3 no skips) (frontier)
- Descriptive Link Text (frontier)
- Alt-Text Writing (W3C four-category decision tree) (frontier)
- Form Label Association (frontier)
- ARIA Labels for Icon-Only Controls (frontier)
- Skip to Main Content Link (frontier)
- Color-Independent Information (frontier)
- Table Captions and Headers (frontier)
- Captions and Transcripts (frontier)
- Reading Level (WCAG) (frontier)
Localization Friendly Writing ●
- Translation-Friendly English Rules (frontier)
- ICU MessageFormat Syntax (frontier)
- CLDR Plural Categories (frontier)
- Named Placeholders (never positional) (frontier)
- Translator Comment Discipline (frontier)
- Pseudo-Localization Testing (frontier)
- Avoiding Text-in-Images (frontier)
- RTL-Friendly Layouts (frontier)
- Key Naming Conventions (frontier)
Audio Script Writing ●
- Cold-Open Pattern (frontier)
- One Idea Per Sentence Rule (frontier)
- Pacing Markers (commas, ellipses, line breaks) (frontier)
- IVR Pause Budgets (100/250/500ms) (frontier)
- Transcription-Friendly Writing (frontier)
- Podcast Show Notes with Chapter Timestamps (frontier)
- Ad-Break Placement (frontier)
- Sample-Dialog for Voice Conversation Design (frontier)
- Broadcast Copy Conventions (frontier)
Visual Writing ●
- Alt-Text (Decorative/Informational/Functional/Complex) (frontier)
- Image and Photo Captions (frontier)
- Video Captions and Sub-Captions (frontier)
- Chart Titles and Axis Labels (frontier)
- Data-Viz Annotations (frontier)
- Edward Tufte Principles (data-ink ratio, chartjunk) (frontier)
- Cole Nussbaumer Knaflic Action Title Rule (frontier)
- Infographic Copy (frontier)
- Pull Quotes and Callouts (frontier)
Sales and Marketing Copy ●
- AIDA Framework (frontier)
- PAS Framework (frontier)
- Schwartz 5 Awareness Stages (frontier)
- Above-the-Fold Hierarchy (frontier)
- Email Subject-Line Patterns (frontier)
- CTA Microcopy (frontier)
- Cold/Nurture/Breakup Email Skeletons (frontier)
- Headline Formulas (frontier)
- Social Proof Typography (frontier)
- Conversion Anti-Patterns (frontier)
Legal Adjacent Writing ●
- Disclaimers and AS-IS Language (frontier)
- MSA and NDA Structure (frontier)
- Terms of Service Architecture (frontier)
- Privacy Notices (GDPR/CCPA/CPRA) (frontier)
- Security Incident Disclosures (8-K Item 1.05) (frontier)
- Warranty and Limitation-of-Liability Clauses (frontier)
- Indemnification with Carve-Outs (frontier)
- Force-Majeure Clauses (frontier)
- SOC2/HIPAA Notice Patterns (frontier)
- Risk-Allocating Contract Architecture (frontier)
Changelogs for Humans ●
- Benefit-Led Language (not feature-list) (frontier)
- Skip-the-Version-Numbers Approach (frontier)
- Screenshots and GIFs for UI Changes (frontier)
- Grouping by Audience Benefit (frontier)
- Linear/Stripe/Vercel/Notion Changelog Pattern (frontier)
- RSS-Feed Friendliness (frontier)
- Monthly Digest Patterns (frontier)
- Mailchimp What's New Email Format (frontier)
- ChangeKeep Readable Conventions (frontier)
Changelog and Release Notes ●
- Keep a Changelog Spec (frontier)
- Semver Communication Obligations (frontier)
- Breaking-Change Announcement Patterns (frontier)
- What/Why/Impact Format (frontier)
- Conventional Commits Mapping (frontier)
- Automation Tooling (release-please, semantic-release) (frontier)
- Deprecation Notices (frontier)
- Migration Guides (frontier)
Release Blog and Launch Narrative ●
- Problem-to-Solution-to-Demo-to-CTA Arc (frontier)
- Why Now Paragraph (frontier)
- What's Not in v1 Honest-Disclosure Section (frontier)
- Embargo and Sequencing (frontier)
- Cross-Channel Launch Ladder (frontier)
- Launch-Day Comms Tree (frontier)
- Pre-Launch Teasers (frontier)
- Success Criteria for Launches (frontier)
- Relaunch Problem (frontier)
Public Speaking and Presentations ●
- Slide-Doc vs PowerPoint Structure (frontier)
- Kawasaki 10/20/30 Rule (frontier)
- Duarte Resonate Framework (frontier)
- Talk Arc Design (frontier)
- Q&A Handling (frontier)
- Rehearsal Discipline (frontier)
- Demo Prep (frontier)
- Virtual vs In-Person Calibration (frontier)
- Opening and Closing Hooks (frontier)
Brand Voice Guide Writing ●
Speech Writing ●
Chatbot Conversation Writing ●
Headline craft ● 1
A/B testing conventions ●
- Five-times rule (Ogilvy) (frontier)
- AIDA mapped to headlines (frontier)
- You-frame rule (frontier)
- Headline numbers (BuzzSumo) (frontier)
- Curiosity-gap vs declarative (frontier)
- Channel-specific length budgets (frontier)
- News vs feature vs op-ed vs SEO registers (frontier)
- Deck / subhead pairing (frontier)
- Upworthy/BuzzFeed clickbait lesson (frontier)
Profile writing ●
- Five-part structure (lede/nutgraf/context/biography/kicker) (frontier)
- Lede patterns (in-scene/anecdotal/paradoxical/delayed) (frontier)
- Nutgraf placement (frontier)
- Show in scene, summarize in transit (Harrington) (frontier)
- Interview-to-prose distillation (frontier)
- Reporting requirement (frontier)
- Ethics (Malcolm) (frontier)
- Fact-checking discipline (frontier)
- Kicker patterns (callback/crystallizing/forward-look) (frontier)
- Talese write-around technique (frontier)
Op-ed writing ● 2
750-word discipline ●
8-paragraph skeleton ●
- Single-thesis rule (frontier)
- Why-now news peg (frontier)
- Authority paragraph (frontier)
- Counter-argument acknowledgment (frontier)
- Evidence selection (Trish Hall) (frontier)
- Voice and register (frontier)
- Call-to-action close (frontier)
- Pitch and submission mechanics (frontier)
Founder Letter Writing ●
- owner-as-partner stance (frontier)
- Toulmin-style spine (frontier)
- recurring principles (frontier)
- what I was wrong about (frontier)
- Day 1 frame (frontier)
- missionary vs mercenary (frontier)
- capital allocation (frontier)
- operating metrics (frontier)
- founder voice (frontier)
- signed sign-off (frontier)
LLM engineering-metaphor tics: term of art versus reflexive tic
- Baseline-frequency test for style words (frontier)
- Candor and sincerity marker tics (frontier)
- Engineering-metaphor vocabulary tics in LLM output (frontier)
- Excess-vocabulary detection method (frontier)
- Literal-referent rewriting protocol (frontier)
- Mixed metaphors as a collapse symptom (frontier)
- Orbital argumentation and catachresis in LLM prose (frontier)
- RLHF annotator-dialect hypothesis (frontier)
- Referent-first drafting prompts (frontier)
- Source-domain collapse in LLM metaphor (frontier)
- Stance adverbs (genuinely, quietly) (frontier)
- Sycophantic openers (frontier)
- Term of art versus reflexive tic (frontier)
- Typicality bias in preference data (frontier)
- Word-swap hook filtering (frontier)
LLM rhetorical-pattern tells in prose
- Awards-and-recognition boilerplate (frontier)
- Contrastive negation and false-dichotomy framing (frontier)
- Excess-vocabulary lists (frontier)
- Four- and five-item list extension (frontier)
- Human style convergence from LLM exposure (frontier)
- Inanimate-subject participles (frontier)
- Perplexity as detection signal (frontier)
- RLHF-induced rhetorical overuse (frontier)
- Rhythm uniformity and burstiness (frontier)
- Sentence-length variance metrics (frontier)
- Significance inflation and promotional puffery (frontier)
- Trailing participial analysis phrases (frontier)
- Travel-brochure register (frontier)
- Tricolon and rule-of-three lists (frontier)
- Tricolon of near-synonyms (frontier)
- Vague attribution to third parties (frontier)
Measuring LLM lexical tics: excess vocabulary, baselines, drift
- Baseline contamination by AI text (frontier)
- Content-word vs style-word annotation (frontier)
- Counterfactual frequency projection (frontier)
- Era-tagging tic entries (frontier)
- Excess-vocabulary frequency method (frontier)
- Frequency ratio vs frequency gap (frontier)
- Human baselines and control words for tic detection (frontier)
- Humanizer tools and paraphrase evasion (frontier)
- Maintaining a living tic list (frontier)
- Non-native writer false positives (frontier)
- Per-model idiolect profiles (frontier)
- Perplexity and burstiness detectors (frontier)
- RLHF-induced lexical overrepresentation (frontier)
- Retiring decayed tics (frontier)
- Stylometry and AI-text detector limits (frontier)
- Tic drift across model versions (frontier)
LLM tells in code, commit messages, comments and READMEs
- Agent attribution trailers (frontier)
- Agent commit-style fingerprinting (frontier)
- Badge walls and generated project-structure trees (frontier)
- Ceremonial layering (frontier)
- Code comment narration and over-explanation (frontier)
- Commit message and PR description tells (frontier)
- Defensive-code and over-engineering signatures (frontier)
- Detector false positives on plain writing (frontier)
- Docstring over-completeness (frontier)
- Duplication over reuse (frontier)
- Good engineering prose versus a tell (frontier)
- Invented changelog entries (frontier)
- Message-code inconsistency (frontier)
- Meta comments (e.g. 'added for X') (frontier)
- Placeholder and debug debris (frontier)
- README and changelog boilerplate tells (frontier)
- Specificity test for a sentence (frontier)
- What-versus-why comment distinction (frontier)
Vague attribution and promotional register in LLM prose
- Anonymous authority phrases (frontier)
- Attribution vs voice in neutral prose (frontier)
- Connective words implying unsupported relations (frontier)
- Cultural-heritage significance framing (frontier)
- Dropping attribution for undisputed claims (frontier)
- Editorial commentary in neutral prose (frontier)
- Overgeneralised consensus from one source (frontier)
- Passive voice hiding the agent (frontier)
- Peacock terms and undue emphasis (frontier)
- Positive-sentiment drift in preference-tuned models (frontier)
- Promotional adjective lists (frontier)
- Rewriting with named sources and plain claims (frontier)
- Significance and legacy inflation (frontier)
- Travel-brochure and promotional register (frontier)
- Vague attribution and weasel wording (frontier)
- Verifying rewritten attributions against source text (frontier)
Mixed metaphors and catachresis as signs of reflexive figurative language
- Career of metaphor (frontier)
- Conceptual metaphor source domains in technical prose (frontier)
- Dead versus live metaphors in engineering writing (frontier)
- Deliberate metaphor theory (frontier)
- Edit protocol for colliding metaphors (frontier)
- Kimmel corpus study of mixed metaphor (frontier)
- Metaphor collision as a detection signal (frontier)
- Metaphor conventionality gradient (frontier)
- Mixed metaphor and catachresis (frontier)
- Per-clause MIPVU-style word labelling (frontier)
- Quintilian on abusio (frontier)
- Read-aloud literal visualization test (frontier)
- Source-domain lexicon overlap check (frontier)
- Technical debt as finance metaphor (frontier)
- War and journey metaphors in engineering (frontier)
Human adoption of LLM vocabulary and its effect on tic baselines
- Consequences for tic lists and detectors (frontier)
- Cross-cultural style convergence in AI-assisted writing (frontier)
- Excess-frequency counterfactual (frontier)
- Exposure-to-active-vocabulary mechanism (frontier)
- Feedback loop and baseline contamination (frontier)
- Homogenization of professional and scientific prose (frontier)
- Human adoption of LLM vocabulary in speech and writing (frontier)
- Measuring convergence against pre-LLM baselines (frontier)
- Model-to-human vocabulary loop (frontier)
- Peer-review homogenization (frontier)
- Perplexity detector bias (frontier)
- Pre-2022 frozen corpora as clean baselines (frontier)
- Speech vs writing adoption (frontier)
- Synthetic control for lexical change (frontier)
- Web prevalence of AI text as corpus contamination (frontier)
- Weighting and dating tic lists (frontier)
- BLUF and Minto Pyramid Frameworks (frontier)
- SCQA Framework (frontier)
- Tone Calibration by Audience (frontier)
- Williams Sentence Craft (nominalization, Given/New) (frontier)
- Zinsser Four Enemies of Clutter (frontier)
- Pinker Curse of Knowledge (frontier)
- Executive Summaries and QBRs (frontier)
- Document Type Templates (frontier)
Dialogue Craft
- Subtext and Dialogue as Action (frontier)
- Silence and the Unsaid (frontier)
- Distinct Character Voice (Idiolect) (frontier)
- Dialect and Accent Rendering Without Phonetic Overkill (frontier)
- Dialogue Tags vs Action Beats (frontier)
- Banter and Dialogue Rhythm/Pacing (frontier)
- Exposition via Dialogue (As You Know Bob) (frontier)
- Interruption and Overlap Mechanics (frontier)
Code Plan Writing ● 2
User Story and Acceptance Criteria ●
- Mike Cohn As-a/I-want/so-that template (frontier)
- INVEST principles (Bill Wake 2003) (frontier)
- Given/When/Then Gherkin acceptance criteria (frontier)
- Vertical-slice rule (frontier)
- SPIDR story splitting (Spike/Path/Interface/Data/Rules) (frontier)
- Acceptance Criteria vs Definition of Done (frontier)
- Ron Jeffries 3 C's (Card/Conversation/Confirmation) (frontier)
- Story sizing (Fibonacci/t-shirt/no-estimates) (frontier)
- Roles vs personas (frontier)
- Anti-stories (bugs/spikes/tech-debt) (frontier)
Spec Writing ●
- WHAT not HOW (Spolsky) (frontier)
- Contract-first design (frontier)
- OpenAPI 3.1 (frontier)
- AsyncAPI 3.0 (frontier)
- Gherkin / Given-When-Then (frontier)
- Spec-as-contract mindset (frontier)
- Versioning conventions (frontier)
- Spec file vs code doc decision (frontier)
- Examples as part of spec (frontier)
- Spec-to-Plan Translation (frontier)
- Task Granularity Design (frontier)
- RFC and ADR Formats (frontier)
- Checkpoint Design (frontier)
- Context Handoff (frontier)
Technical Instruction & Engineering Education ● 8
Instructional Design & Course Architecture ●
- ADDIE (frontier)
- SAM (Allen) (frontier)
- Dick & Carey systems model (frontier)
- Backward Design / UbD (frontier)
- Scope-and-Sequence & Prerequisite DAGs (frontier)
- Learning Objectives (ABCD / Mager, Bloom's verbs) (frontier)
- Constructive Alignment (Biggs) (frontier)
- Gagné's Nine Events (frontier)
- Merrill's First Principles (frontier)
- Course Format Decisions (frontier)
Technical Assessment & Certification Design ●
- Item Writing (MCQ & performance-based) (frontier)
- Psychometrics (CTT item analysis, IRT, KR-20) (frontier)
- Validity & Reliability (frontier)
- Cut Scores (Angoff, Bookmark) (frontier)
- Job Task Analysis (frontier)
- Test Blueprints (frontier)
- ANSI/ISO 17024 & NCCA Accreditation (frontier)
- Exam Security & AI-Resistant Assessment (frontier)
- Open Badges 3.0 & Micro-Credentials (frontier)
Technical Training Delivery & Developer Education ●
- Participatory Live Coding (frontier)
- Hands-on Labs & Sandboxes (frontier)
- Scaffolding, Fading & Parsons Problems (frontier)
- Teaching SQL/NoSQL & Notional Machines (frontier)
- Peer Instruction (frontier)
- Customer Academy Program Model (frontier)
- DevRel Education (frontier)
- Partner/SI Enablement (frontier)
- Modalities (ILT/self-paced/blended) (frontier)
- Screencast & Microlearning Production (frontier)
Teaching Troubleshooting & Diagnostic Reasoning ●
- Cognitive Apprenticeship (frontier)
- Productive Failure (Kapur) (frontier)
- Mental-Model Instruction (frontier)
- Novice-to-Expert Trajectory (frontier)
- Worked-Example Fading (frontier)
- Illness Scripts (frontier)
- Dual-Process Theory (frontier)
- Key-Feature Assessment (frontier)
- Game-Day / Fire-Drill as Pedagogy (frontier)
Learning Measurement & Training Evaluation ●
- Kirkpatrick Four Levels (frontier)
- New World Kirkpatrick Model (frontier)
- Phillips ROI (Level 5) (frontier)
- xAPI / SCORM / cmi5 (frontier)
- Learning Record Store (LRS) (frontier)
- Training Transfer (Baldwin-Ford, LTSI) (frontier)
- Leading vs Lagging KPIs (frontier)
- L&D Dashboard Design (frontier)
GenAI for Instructional Design & AI Tutors ●
- AI-Assisted Instructional Design (HITL) (frontier)
- LLM Tutors / ITS (Khanmigo, LearnLM) (frontier)
- Bloom 2-Sigma & Socratic Tutoring (frontier)
- Automated Item Generation (frontier)
- Adaptive / Personalized Learning (frontier)
- GenAI in CS Education (amplifier vs equalizer) (frontier)
- Cognitive Offloading (frontier)
- FERPA/COPPA & AI Equity (frontier)
- AI-Resistant Assessment (learning) (frontier)
Human Performance Technology & Performance Support ●
- ISPI/HPT Model (performance → cause → intervention) (frontier)
- Gilbert's Behavior Engineering Model (BEM, 6-cell, environment-first) (frontier)
- Mager & Pipe Performance-Analysis Flowchart (frontier)
- Rummler-Brache Three Levels & Nine Performance Variables (frontier)
- HPT Intervention Taxonomy (frontier)
- Performance Support & EPSS (Gery intrinsic/extrinsic/external) (frontier)
- Digital Adoption Platforms (WalkMe/Whatfix/Pendo) (frontier)
- Five Moments of Need (Gottfredson & Mosher) (frontier)
- Job Aid Design (step-by-step/checklist/decision-table/worksheet) (frontier)
- Learning in the Flow of Work (frontier)
- Performance Consultant Role & Tacit-Knowledge Limitation (frontier)