Eleven years in Salesforce, the last two spent building the AI the platform did not ship with: an agentic control plane over the org, autonomous Apex test generation inside the Einstein trust boundary, and an agent driven delivery pipeline that carries a ticket from branch to deployment to written documentation.

Five scored lenses over one Salesforce estate, covering spend, health, adoption, commitment and data. Each finding is priced in dollars where a defensible rate exists, and the lot is ranked as a single backlog under one composite score. The question it answers is not "is the org healthy" but "what should we do next week, and what is it worth".

• The composite is capped at 15 points above the weakest lens. A majority of healthy lenses is not allowed to mask a critical one, which is exactly what an average would do.
• Roughly 90 percent of it has no model in it at all. Deliberate: a number that needs a model to produce is a number nobody can audit.
• Cannot write to production by construction. Not configured not to. The class that talks to production issues GET and contains no method capable of sending a record.
• The agent proposes, a human disposes. The analyst runs in GitHub Actions, writes a fix and opens a draft pull request. It never auto merges. Change plans go propose, approve, dispatch, verify, and the executor takes an id, not a payload, so the set of things it can do is exactly the set somebody read and approved.
• Provenance is read from the data, not the settings. A source badge rendered from configuration once displayed a stale sandbox snapshot under a production label. It now reads the org stamped on the rows themselves.

Salesforce native autonomous Apex test generation, coverage measurement and failing test repair, built against an org of over 1,000 Apex classes carrying a backlog of failing test methods and classes with no test at all.

• Runs on the in platform Models API, behind the Einstein Trust Layer. No external callout, no API keys, and no code leaves the Salesforce trust boundary.
• Model agnostic through configuration. The model name is config, so it can be repointed without a deploy.
• Four modes: generate a new test class, extend an existing one while preserving every method, repair to close a coverage gap, and fix a broken developer written test.
• Every prompt carries hard rules that are scar tissue from observed failures. The load bearing one: every method must contain a meaningful assertion. Without it a model writes a method that calls everything, asserts nothing, and reports full coverage.
• Bulk and delta aware. Rules force a 200 record scenario, because governor limits are where Salesforce code actually breaks, and delta based count assertions, because org automation creates extra records.

Authored skills that take a ticket the whole way through delivery, with the release tooling underneath built as a native Salesforce application.

• The skills cover the full loop: branch and pull request, validation and deployment, generated unit tests, the Confluence technical write up, and the Jira status update.
• The tooling underneath is a native Salesforce CI/CD app I built: a Lightning Web Component application unifying Salesforce, GitHub and Jira, replacing hand built package.xml files, CLI deploys and manual ticket updates.
• An 8 step staging pipeline and a 9 step production pipeline, the second adding a code review gate before validation. A ticket can sit in a staging and a production release at once, matching how work actually promotes.
• Deployment through GitHub Actions with automatic quick deploy fallback, real time progress polling, and capture of component counts, test results and error detail back onto the run record.
• Path resolution across 40+ metadata types, including child metadata, folder based bundles and the types with irregular naming that break naive implementations. Pipeline behaviour lives in Custom Metadata, so it retunes without a deploy.

The applied end: getting generative features in front of support agents, then measuring whether they were actually worth the credits.

• Instrumented the Support AI platform. Prompt metric tracking and agent feedback across Suggested Reply, Similar Cases and Internal Assistance, which previously had no visibility into whether agents found the output useful.
• Agentforce case deflection proof of concept, and grounded case comment generation through Prompt Builder on the case comment screen.
• Similar case matching on the Case record, matched on subject, description, issue type and product, restricted to resolved cases with real comments.
• Agentforce Flex Credit overage root cause analysis and control playbook, written as an internal leadership briefing: what was over, where the credits went, when, why, and the controls to stop it recurring.
• Salesforce MCP adoption with propose, approve, dispatch and verify gating, and independent checks that prove the target org is a sandbox before any write leaves.