Guided Paths
Some topics are easier to understand as a sequence instead of a single article. These series group related posts into a path that shows where to start, what is already available, and how the discussion builds over time.
AS/C
A personal-essay series that reconstructs the vocabulary of AI-native software one concept at a time, asking what changed, what is genuinely new, and where the historical analogy to earlier engineering ideas breaks down.
This series follows a 16-post roadmap toward a future book of the same name, adding one concept per post.
AI-native software is not accumulating terminology by accident: its expanding vocabulary reflects a new model-mediated abstraction layer forming inside software architecture.
Web search is turning into a bounded, multi-round loop where a model helps choose what to search next and when to stop, and that loop deserves the same architectural discipline as any other production system.
An agent is not simply a model with a prompt: it is a model-driven control loop, and the real architecture decision is how much of that loop stays under deterministic control.
As enterprise data and capabilities spread across systems, multiple consumers need shared context and governed capability through different experiences. The application boundary weakens, but does not disappear.
Tool calling lets a model propose a structured capability invocation while an execution host retains authority over authorization, validation, side effects, and outcomes.
Model Context Protocol gives AI hosts a shared contract for discovering and exchanging context and capabilities, but interoperability does not replace authorization or domain policy.
Context engineering treats a model's working set as a designed runtime system, selecting instructions, data, tools, history, and constraints for a bounded, observable decision.
RAG adds external evidence to generation; agentic RAG makes search, inspection, and stopping decisions part of a bounded control loop.
Agent memory is not a second context window: it is a governed write, manage, and read path that persists selected state without turning every prior observation into truth.
Inference-time compute turns model responses into a budgeted search and verification problem, changing how software trades accuracy, latency, cost, and control.
Deep research turns retrieval into an evidence-producing workflow that plans an investigation, inspects sources, tracks provenance, and synthesizes a report under explicit limits.
Computer use lets a model operate software through visual and interactive interfaces, extending automation into the long tail of systems while making state, authority, and safety explicit.
Agentic workflows place model-mediated decisions inside explicit orchestration, preserving deterministic control over state, side effects, retries, authority, and release.
Multi-agent systems distribute model-mediated work across coordinated agents, trading specialization and parallelism for communication, consistency, cost, and accountability.
Evals turn variable model behavior into an evidence problem, combining deterministic checks, outcome verification, repeated trials, human review, and LLM judges without confusing a score with correctness.
Guardrails make probabilistic software operable by combining structured outputs, semantic checks, policy, permissions, approval, constrained execution, and outcome verification.
A model gateway centralizes access, routing, policy, reliability, and cost across model deployments, but model choice is part of application semantics rather than an invisible transport detail.
AS/A/SF
An architecture-first series about how Salesforce-native applications evolve from explicit CRM automation toward AI-assisted work.
A companion platform-native series to The Abstraction Shift, mapping its vocabulary onto the Salesforce platform boundary rather than repeating it. Posts are planned to alternate publishing days with The Abstraction Shift.
Salesforce is evolving from explicit CRM automation to AI-assisted work, changing how teams design context, authority, transactions, integrations, and proof of outcome.
AIforce and Agentforce open different surfaces of the Salesforce application: one carries Salesforce context and governed capabilities to other interfaces, while the other runs agents inside the platform's application runtime.
EAI
A practical path from AI foundations to production architecture, focusing on where AI fits, where it does not, and what changes when systems move into real delivery contexts.
Paused since September 2025 while The Abstraction Shift and AI-Native Architecture on Salesforce are the active tracks. The existing posts remain a useful path; new installments are not currently scheduled.
This series presents a structured AI roadmap designed for engineers and technical professionals, emphasizing essential concepts and advanced applications like LLM Ops and AI security. The content focu
AI's path was never linear: from Turing and the Golden Age, through two AI winters, to the deep learning revolution and generative AI that defines the field today.
AI, ML, and deep learning form a nested hierarchy. Understand the core differences with examples, and why deep learning drives modern AI breakthroughs.
AI handles ambiguous, rule-breaking problems; control flow handles deterministic logic. Most real systems blend both: AI for perception, control flow for enforcement.
ENG
Reusable engineering patterns for Salesforce and adjacent systems: frameworks, JavaScript fundamentals, and implementation discipline that survives real production pressure.
Paused since August 2025. Additional deep dives can still extend this track without changing the core path shown here; none are currently scheduled.
Evolve your Apex frameworks from core essentials to AI-native solutions. Build secure, scalable foundations compatible with AI-assisted code generation and modern tooling.
An AI-ready Apex Trigger Framework in Salesforce. Learn the architecture, best practices, detailed Apex code, AI prompt templates, and pitfalls to avoid. Designed for scalability, maintainability, and
Every Lightning Web Component runs on JavaScript. This series covers variables, functions, events, async patterns, and ES6+ features that every LWC developer needs.
Master `let`, `const`, and `var` in LWC. Block scope, function scope, and closure rules determine how variables behave inside components and affect state and rendering.
Learn when to use traditional functions vs. arrow functions in LWC. Arrow functions inherit `this` lexically, solving common event handler bugs in Lightning components.
SFA
A series on treating Salesforce as part of a broader enterprise platform: architecture runway, cost control, operating model, and long-term system shape.
Paused since August 2025. AI-Native Architecture on Salesforce now covers this ground at the platform-boundary level; future Salesforce operating-model posts may resume here or fold into that series instead.
Transform Salesforce from a departmental tool into strategic enterprise infrastructure — scalable, integrated, and aligned across sales, service, and operations.
Balance innovation and discipline on Salesforce by managing cost drivers, controlling lock-in, and adopting architectural patterns that protect your platform investment.
Measure real Sales Cloud ROI without perfect benchmarks. Track pipeline velocity, forecast accuracy, adoption, and productivity — starting from where you are now.