Writing
Real-world perspectives on enterprise architecture, AI systems, and platform strategy.
Start with a few curated entry points, then browse the archive by topic or time. If you prefer a guided path instead of individual posts, follow the series guide.
Newest first. Use the topic filter and timeline to narrow the archive without losing chronology.
AS/C The Abstraction Shift: How Software Keeps Moving Up
A successor that scores higher has improved. Recursive self-improvement is the stronger claim that it also got better at producing the next improvement, and that claim needs evidence the candidate cannot rewrite.
AS/C The Abstraction Shift: How Software Keeps Moving Up
A system that can rewrite its own planner or tools needs controls it cannot rewrite. A higher score earns a candidate a review, not the right to become the active version.
AS/C The Abstraction Shift: How Software Keeps Moving Up
An agent can run the experiments that improve an AI system. The objective, the evaluator, and the release decision still need owners outside the loop.
AS/C The Abstraction Shift: How Software Keeps Moving Up
A clean diff and passing tests do not make an agent's change releasable. Someone still has to accept it, release it, operate it, and repair it.
AS/C The Abstraction Shift: How Software Keeps Moving Up
A shared protocol helps systems communicate. The work still needs permissions, ownership, and a definition of done.
AS/C The Abstraction Shift: How Software Keeps Moving Up
A trace explains what an agent attempted, but only a check against the responsible system shows whether the intended result actually happened.
AS/C The Abstraction Shift: How Software Keeps Moving Up
An agent can interpret a request, but the authority to act has to come from a scoped, attributable grant that the system checks at every boundary.
AS/C The Abstraction Shift: How Software Keeps Moving Up
An agent task that outlives its request needs saved state another worker can safely resume from, not just a job ID.
AS/C The Abstraction Shift: How Software Keeps Moving Up
A predictable response format helps software read the answer. It still has to check the proposed action.
AS/A/SF AI-Native Architecture on Salesforce
An agent's work on Salesforce belongs in Flow, Apex, a model call, a durable process, or an external system according to who owns each step and how that step recovers from failure.
AS/A/SF AI-Native Architecture on Salesforce
A Salesforce agent should call a refund complete only after the request, authority, payment, and final state have been checked independently.
AS/A/SF AI-Native Architecture on Salesforce
Before a Salesforce agent approves a replacement, it needs the right facts, reliable sources, and a clear response when information is missing.
AS/A/SF AI-Native Architecture on Salesforce
Agent Script combines model reasoning with explicit control flow, making agent behavior a design problem about determinism, state, transitions, actions, and human authority.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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 AI-Native Architecture on Salesforce
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
Guardrails make probabilistic software operable by combining structured outputs, semantic checks, policy, permissions, approval, constrained execution, and outcome verification.
AS/A/SF AI-Native Architecture on Salesforce
Salesforce is evolving from explicit CRM automation to AI-assisted work, changing how teams design context, authority, transactions, integrations, and proof of outcome.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
Multi-agent systems distribute model-mediated work across coordinated agents, trading specialization and parallelism for communication, consistency, cost, and accountability.
AS/C The Abstraction Shift: How Software Keeps Moving Up
Agentic workflows place model-mediated decisions inside explicit orchestration, preserving deterministic control over state, side effects, retries, authority, and release.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
Deep research turns retrieval into an evidence-producing workflow that plans an investigation, inspects sources, tracks provenance, and synthesizes a report under explicit limits.
AS/C The Abstraction Shift: How Software Keeps Moving Up
Inference-time compute turns model responses into a budgeted search and verification problem, changing how software trades accuracy, latency, cost, and control.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
RAG adds external evidence to generation; agentic RAG makes search, inspection, and stopping decisions part of a bounded control loop.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
Tool calling lets a model propose a structured capability invocation while an execution host retains authority over authorization, validation, side effects, and outcomes.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
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/C The Abstraction Shift: How Software Keeps Moving Up
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.
AS/C The Abstraction Shift: How Software Keeps Moving Up
AI-native software is not accumulating terminology by accident: its expanding vocabulary reflects a new model-mediated abstraction layer forming inside software architecture.
How to structure branches, worktrees, and promotion gates when building with agents as a solo developer or small team. Isolation, gated integration, and selective promotion without enterprise infrastructure.
AI infrastructure costs feel manageable at launch and surprising at scale. The compounding effect of token growth, optional operational layers, and cost volatility creates a very different budget reality than the initial estimate suggests.
Over-architecture is rarely deliberate. It builds through resume-driven engineering, vendor influence, and big-tech pattern copying, until the architecture exceeds the problem it was meant to solve.
AI features appear simple on the surface but introduce hidden architectural weight: new systems, pipelines, and governance gaps that compound before the project has a name. Here's how to measure it before it becomes unmanageable.
EAI Enterprise AI Playbook
AI, ML, and deep learning form a nested hierarchy. Understand the core differences with examples, and why deep learning drives modern AI breakthroughs.
EAI Enterprise AI Playbook
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
ENG Engineering Practices
Learn when to use traditional functions vs. arrow functions in LWC. Arrow functions inherit `this` lexically, solving common event handler bugs in Lightning components.
EAI Enterprise AI Playbook
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.
ENG Engineering Practices
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.
ENG Engineering Practices
Every Lightning Web Component runs on JavaScript. This series covers variables, functions, events, async patterns, and ES6+ features that every LWC developer needs.
EAI Enterprise AI Playbook
AI handles ambiguous, rule-breaking problems; control flow handles deterministic logic. Most real systems blend both: AI for perception, control flow for enforcement.
Convert unstructured text — emails, notes — into Salesforce records using the Models API. Scans your org schema dynamically and maps text to custom objects and fields.
ENG Engineering Practices
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
Use the Web Share API in LWC to open native share sheets — WhatsApp, Teams, Mail — so users can share Salesforce records in one tap on mobile. No Apex required.
Salesforce now generates OpenAPI 3.0 specs from your org. Use them for Postman, SDK generation, and docs — keeping API definitions in sync with your implementation.
ENG Engineering Practices
Evolve your Apex frameworks from core essentials to AI-native solutions. Build secure, scalable foundations compatible with AI-assisted code generation and modern tooling.
Integrate Google Gemini with Salesforce Apex to classify and validate Cases in real time, improving routing accuracy and preventing SLA breaches automatically.
SFA Salesforce Architecture
Measure real Sales Cloud ROI without perfect benchmarks. Track pipeline velocity, forecast accuracy, adoption, and productivity — starting from where you are now.
Leverage your existing Salesforce CLI session to skip OAuth setup for temporary scripts. Extract the access token and call the API without configuring a Connected App.
SFA Salesforce Architecture
Balance innovation and discipline on Salesforce by managing cost drivers, controlling lock-in, and adopting architectural patterns that protect your platform investment.
SFA Salesforce Architecture
Transform Salesforce from a departmental tool into strategic enterprise infrastructure — scalable, integrated, and aligned across sales, service, and operations.
Understanding financial statements helps tech leaders navigate enterprise decisions about investments, negotiations, and strategic alignment with finance teams.
TLS security depends on negotiated cipher suites, not just the padlock icon. Understand the TLS handshake, cipher selection, and why TLS 1.3 removes legacy cryptography.
No posts match the current topic and timeline filters.
I earned the Einstein Analytics and Discovery Consultant cert after two failed attempts. What changed: completing both super badges, hands-on SAQL work, and focused study.
Manage multiple JDK versions on Mac using Homebrew and jenv. Install different OpenJDK builds and switch between them without affecting your system default.
I earned Salesforce Certified Platform Developer II after super badges and the PD1 exam. Focus: Apex, Visualforce, data modeling, performance tuning, and integration.
The complete Einstein Analytics architecture: data sources, datasets, transformations, and analysis tools. Understand dataflows, recipes, lenses, and dashboards at a glance.
Generate package.xml and deploy metadata with all dependencies in minutes using unmanaged packages and SFDX, avoiding manual conflict resolution and changeset limits.
JWT is an open standard for secure information exchange. It consists of header, payload, and signature — each base64 encoded and cryptographically signed using RS256.
Quick tip: Run a short browser console script on a profile's FLS page to check all permission checkboxes at once instead of clicking manually through every field.
Use login flows to lock users out during deployment with a friendly message and optional passcode — more graceful than freezing users or deactivating profiles.
Embed existing HTML/JavaScript projects into Salesforce using static resources and iframes. Skip Visualforce conversion and load full web apps with minimal effort.
The Sales Cloud Consultant cert tests analytical and problem-solving skills. Requires 1-2 years consulting experience and depth in SDLC, forecasting, and security models.
I cleared the Salesforce Certified Administrator exam after 2+ years on the platform. What worked: official study guide, hands-on practice, and focused syllabus review.
Use field sets and JSON metadata to build dynamic Visualforce pages that adapt to multiple record types without code changes — fields and layouts adjust through config.
