You will learn why Apex has no local run loop, what a local Apex runtime changes for testing, debugging and CI, and which platform rules still apply locally.
Why read this
The article is a vendor-led introduction to a third-party tool, so weigh its claims accordingly.
The article explains that Apex looks like Java but only compiles, runs and tests inside a Salesforce org, so every iteration means deploying, waiting and reading logs. It argues that this deploy-to-run loop is slow, and that CI pipelines need an org and certificate just to run unit tests. Its benchmark claims four open-source Apex suites of 837 tests took about 1 min 46 s in an org versus 2.4 s locally, with every test passing in both.
The author presents Renmy Runtime, a single binary that executes Apex, SOQL, DML and Salesforce Flows on a developer’s machine against an embedded PostgreSQL, with no org, Docker or JVM. Commands such as renmy test, renmy validate and renmy explain run tests, type-check changes and explain failures, and the tool reports line and branch coverage. A JetBrains plugin adds breakpoints in IntelliJ IDEA, a SOQL and Apex console, and mutation testing as a Pro feature. The CI example runs the suite and emits JUnit XML and Cobertura without an org.
The piece is candid that some differences remain: governor limits, order of execution and metadata-defined schemas still apply, and the runtime is not the platform itself. It recommends keeping sandboxes or Scratch Orgs for UI, integration and final validation, with renmy deploy checking the same bytes in the org before release.
You will learn how Salesforce engineers split deterministic code from AI reasoning in an MCP workflow that clusters and reassigns test failures, and which guardrails prevented duplicate work items and misrouting.
Why read this
The reasoning is useful even if you never touch the GUS internals.
Retrieve failures
Gather context from stack traces
Detect patterns or apply categories
Reassign individually, in bulk or by team
The workflow runs through four stages, from retrieval to reassignment
Salesforce’s engineering team faced over 600 test failures triggered by the retirement of the SOAP API login mechanism. Expected failures and genuine regressions could produce similar exceptions and span several scrum teams, so a wrong classification could hide a real defect or send engineers chasing the wrong problem for days. The existing process required manual stack trace reading and reassignment through an interface limited to 50 failures at a time, and it could create duplicate work items or misroute failures.
The team built AI-Assisted Test Failure Buddy as a Python and FastMCP process exposing eight tools to Claude Code or Cursor, connected to the APIs behind GUS, Salesforce’s internal work item system. The design separates an interface layer of typed MCP tools, a core logic layer that controls API calls, identifiers, parsing, validation, batching, clustering and reassignment, and a support layer for authentication and tokens. The workflow runs in four stages: retrieve failures, gather context from stack traces, detect patterns or apply categories, and reassign failures individually, in bulk or by team.
Grouping was the hardest part. Stack traces offer no stable key for root cause, and the same exception type could mean an expected SOAP login failure in one context and an unrelated bug in another. The team combined deterministic processing, such as regular-expression matching and a preset recognizing strings like INSUFFICIENT_ACCESS, with AI reasoning reserved for novel traces, unmatched clusters and ambiguous ownership. To avoid duplicates, the tool assigns related failures to one existing work item and uses explicit failure IDs in place of the broader interface action that had caused misrouting.
The estimated two or three days of manual triage for one 600-failure work item fell to roughly one to one and a half hours for a single engineer. The tool has since been used by three or four teams, though it has no adoption telemetry yet. The article also notes that Claude Code helped build the tool, starting from a markdown design document with human review throughout.
You will learn what the Metadata Visualizer and Live Preview VS Code extensions show, which metadata types and UI bundles they cover, and how to open them.
Why read this
It helps you judge whether they fit a workflow built on agents and the Headless Toolkit.
Setup and XML route
Retrieve long XML file
Navigate Setup to change permissions
Retrieve updated metadata
Commit changes to version control
Headless Toolkit route
Query and modify from terminal
Edit metadata locally
No retrieve after changes
Run operations in parallel
Editing a Permission Set with and without the Headless Toolkit
Building with agents lets developers skip many Setup clicks, but it removes the visual context that makes Flows and Permission Sets easy to grasp. The post presents two VS Code extensions, Metadata Visualizer and Live Preview, as a way to restore that context. It frames them as the visual companion to the Headless Toolkit, which combines agent skills, hosted MCP servers and the Headless Experience Layer.
The author describes the Headless Toolkit through a Permission Set example. Working through Setup meant retrieving a long XML file, navigating menus to understand and change permissions, then retrieving and committing the result. Through agents and the toolkit, the same change can be queried and edited from the terminal in seconds, locally and in parallel, without repeated round trips.
Metadata Visualizer renders read-only views of Salesforce metadata and comes with the Salesforce Extension Pack for VS Code. It covers agents, Flows, Lightning pages, objects and Permission Sets as of November 2026, and is opened by clicking Visualize in the editor. Users can analyze in the visualizer and ask an agent to apply changes, and with Agentforce Vibes they can select elements to have the agent edit them. Live Preview covers Lightning Web Components and Multi-Framework UI bundles, using live org data, and HXL widgets, using sample data that can be customized as JSON.
The post closes by suggesting that future interactive widgets could show metadata directly in agent responses, replacing some of these extensions and builders.
You will learn how to define a Copilot custom agent that audits Apex for PMD and OWASP-style security issues inside the IDE, without external integrations.
Why read this
You will also see the review output format and the tool restrictions that keep the reviewer read-only.
The article argues that static analysis of Apex usually runs too late, in a CI pipeline that fails a pull request after the developer has finished the work. In locked-down enterprise orgs, adding external AI review bots or webhooks is often blocked by security approval, so the author proposes a review agent that stays inside the existing GitHub Copilot boundary.
The agent is a declarative Markdown file, a .agent.md, stored in .github/agents/ for team sharing or in ~/.copilot/agents/ for personal use. It has a YAML header that gives its name, description and permitted tools, here restricted to search and fetch so the agent cannot modify files. The body is a system prompt that lists the rules to check, such as ApexCRUDViolation, ApexSOQLInjection, OperationWithLimitsInLoop and AvoidHardcodingId, grouped by security, performance, architecture and test quality.
The author gives a sample service class with a concatenated dynamic SOQL string, no sharing keyword, no user-mode enforcement and a DML statement inside a loop. The agent reports each issue with a severity, the rule name, the file and line, a short explanation and a compliant fix. The article closes with three team practices: keep shared conventions in copilot-instructions.md, restrict reviewer tools to read and search, and keep deterministic Salesforce Code Analyzer runs in the pull-request pipeline for audit trails.
You will learn seven ways Apex and LWC code can pass its tests yet fail in a real org, including keyset paging, retried saves, restricted picklists and cacheable methods.
Why read this
Each comes with a concrete fix and a check you can run on your own code.
Recursion guard (bug 2)
Static Id set skips retried records
Silent skip with all-or-none off
Compare old and new values instead
Cacheable refresh (bug 5)
cacheable=true returns stale rows
Mocked Jest tests cannot catch it
Drop cacheable or use refreshApex()
The author's fixes for two of the seven bugs, set side by side
The author’s starter kit had 113 passing tests, 68 Apex and 45 Jest, and deployed cleanly to a real org. A tester clicking through the data table and a reviewer reading the code together found seven bugs that no test had caught. The gaps lay between what the tests checked and what a live org did.
The first bug was a paged table that kept showing page one. The server used a keyset cursor, and a cached browser component sent only a page number, so the server treated every request as page one. The tests called each version with the arguments it expected, so an old client against a new server was never tested. The fix is to fall back to offset paging when a later page arrives without a cursor, and to check what an old client would receive after changing an @AuraEnabled contract. The second bug was a static Id-based recursion guard that silently skipped retried records when a save ran with all-or-none off. The fix is to compare old and new values and recalculate for work that is safe to repeat, keeping an Id guard only for work that must happen exactly once.
The third bug was a logger whose Platform Event carried any LoggingLevel name, while the Log__c picklist allowed only ERROR, WARN, INFO and DEBUG. Logs finer than DEBUG failed silently in the subscriber trigger. The fix is to store anything finer as DEBUG, and to test every restricted picklist with a value outside its list. The fourth was an example Account trigger shipped switched on, which changed the data of anyone who deployed the kit. Example code should ship disabled, and the tests should enable handlers only while they run.
The fifth bug was a refresh() method that could show stale rows, because the backing Apex method was cacheable. Jest mocks cannot catch this, so it appears only in a real browser. The fix is to drop cacheable=true where current data matters, or to use @wire with refreshApex(). The sixth was a no-CLI zip, built by hand, that still held six older files. The fix is to build the zip from the source folder in one script, compare every file, and deploy the zip as the final test. The seventh was an offset calculation that overflowed for very large page numbers before the row-limit check ran. The fix is to compare before multiplying.
The author groups the bugs into gaps between versions, between code and platform, between the developer’s org and the buyer’s, and at input edges nobody types on purpose. The closing advice is that passing tests cover only what the developer thought of, so manual testing and fresh review are needed before calling code production-ready.
You will learn a repeatable way to list the active Flows, Validation Rules and triggers on an object using the Salesforce CLI and pandas, so a reviewer can see what a change will collide with before it ships.
Export active Flows with SOQL
Export active Validation Rules
Export active triggers via Tooling API
Filter the exports by object in pandas
Attach the tables to the ticket for review
The article's method for finding existing automation on an object before shipping an AI-generated change
The article argues that an AI-drafted Flow, Apex class or Validation Rule must be checked against everything else already running on the same object. Before review, the author suggests finding that automation first, since a clean-looking change can clash with an existing rule, loop with another Flow, or overwrite a field a batch expects to be empty.
The method uses the Salesforce CLI to export active Flows with a SOQL query on FlowDefinitionView, and active Validation Rules and triggers through the Tooling API. Triggers are matched on their object, while Flows have no dedicated object field, so the author scans API name, label and description instead, which is imperfect but faster than opening every Flow. A short pandas script then filters the three exports for a chosen object such as Opportunity and produces a review agenda.
The author adds that managed package automation will also show up in these results. Managed items cannot be edited but can still fire after a change, so they belong in a separate list. The tables should be attached to the ticket so the next reviewer does not have to rerun the queries.
The piece also proposes three test cases a model often skips: a record that must be blocked with a clear message, a record that must pass even when a field arrives late, and the same change run by a non-admin user. It lists reasons to wait a day before shipping, such as a missing description, tests that check coverage rather than the business rule, or a field the model invented. The article is practical and short, and the queries are the main takeaway.
You will learn how to confirm every archive, object and file arrived from a Data Export and how to reconcile CSV row counts against SOQL COUNT() before a target load.
Why read this
You will also learn the documented gaps, such as excluded Formula Fields and Recycle Bin data.
Download every archive within 48 hours
Confirm each expected object CSV is present
Confirm attachments and files were included
Compare each CSV row count to SOQL COUNT()
A sequence of checks to run on a Data Export before migrating from it
A finished Data Export job does not guarantee a complete file set. Archives can be missing, expire after 48 hours, or be overwritten when a new export is queued, so the piece recommends downloading every zip promptly and counting them against what was saved. It also flags that Sandboxes do not support Data Export and that the scheduling user receives the download email.
The article then covers checking objects and files: forgetting to tick the options for attachments or Salesforce Files leaves files out, Formula Fields and Roll-Up Summary Fields are always excluded, and Data Loader does not obtain physical attachments. Chatter and content files in weekly exports come as MIME files named after the record ID, and Data Loader’s ContentDocument export only returns files the user owns or that are shared directly with them unless Query All Files is granted.
For row counts, the author compares each CSV’s data rows to a SOQL COUNT() run by a user with comparable visibility, matching the export mode to the query, and counting outside Excel for files above about 1,048,576 rows. A worked spreadsheet example with Match and Review status formulas shows how a short Contact file is caught. A matching count does not prove that attachments open or that parent relationships are correct.
You will learn why output measures such as tickets closed and pull requests merged can mislead when judging AI-assisted development, and which DORA metrics, including the newer rework rate, show whether AI is saving time.
Why read this
The article also covers the human signals to watch alongside them.
Deployment frequency
Lead time to change
Change failure rate
Time to recover
Rework rate
The four DORA metrics plus rework rate, used together to test whether faster delivery costs stability
The article argues that organisations judge AI-assisted development by activity such as lines of code, tickets closed and pull requests merged, which are easy to game and say little about whether the work is valuable. It cites Google’s DORA research finding that rising AI use correlates with greater org instability, and that the rework this creates can consume the time AI was meant to save.
The author recommends returning to the four DORA metrics: deployment frequency, lead time to change, change failure rate and time to recover, together with the rework rate metric DORA added in 2024. Taken together, these show whether faster delivery is coming at the cost of stability. The author also stresses that the numbers show what is happening but not why, so teams should track human signals such as trust in AI output, verification load and user adoption.
The piece closes with a promotional section for Gearset’s AI agent Cam and its DevOps performance dashboard, which tracks DORA metrics from a pipeline. The promotional content is brief and the general guidance stands apart from it.
You will learn how the new AiAgentDefinition and AiAgentDefinitionVersion types replace Bot, GenAiPlannerBundle and AiAuthoringBundle for Agentforce agents, how to write a manifest and retrieve a single version with its dependencies, and which deployment rules and migration steps apply.
Agentforce agent at API 68.0
AiAgentDefinition
AiAgentDefinitionVersion
AiAuthoringBundle
The three old metadata types and the two new types that replace them
Winter ’27 introduces two metadata types for Agentforce agents at API version 68.0: AiAgentDefinition, which holds agent-level settings, and AiAgentDefinitionVersion, which holds one version’s settings, messages and an inline planner with its subagents and actions. Under the previous structure, one agent was spread across the Bot, GenAiPlannerBundle and AiAuthoringBundle types, with generated name suffixes, hard-to-find welcome messages and folder names that changed between retrieves. The author compares a sample agent retrieved at API 67.0 and 68.0, showing that the content was identical and only the names and packaging changed.
At API 68.0, Agentforce agents must use the new types, and retrieving or deploying them as Bot or BotVersion returns an error. The # delimiter lets a manifest or the –metadata flag select a single version, such as TestAgent#1, all versions with TestAgent#, or every version of every agent. Salesforce CLI version 2.149.9 or later is needed, and the –root-type-with-dependencies AiAgentDefinitionVersion flag pulls in the parent definition, the authoring bundle and the Flows, Apex classes and Prompt Templates the version uses. The dependency retrieve is limited to 25 requests per day, 100 components per request, and one level deep.
Deployments fail if the old and new formats are mixed, if a version is deployed without its definition existing in the target org or the same deployment, or if the Agent Script source is omitted. The author also notes that the agent user from the source org must be replaced for a draft agent, and recommends switching to API 68.0 in its own commit and updating any scripts that parse the old files.
By Mohith Shrivastava · Salesforce Developers BlogYou will also see how to keep the agent's context lean and feed each mistake back into the project's instructions, checks and specs.
You will learn how to structure a Salesforce project around coding agents, using Skills, hosted MCP Servers and the Salesforce CLI across seven stages from grounding to observation.
Why read this
You will also see how to keep the agent's context lean and feed each mistake back into the project's instructions, checks and specs.
Ground in business and org
Specify what to build
Build with the agent
Verify with tests and checks
Review with a reviewer agent
Release through a human gate
Observe and feed mistakes back
The seven stages of the agent-driven Salesforce lifecycle, each leaving an artifact for the next
This Salesforce Developers Blog post, written by Principal Developer Advocate Mohith Shrivastava, proposes an agent-driven development lifecycle built on the Headless Toolkit: the Salesforce Skills Library (sf-skills), Salesforce Hosted MCP Servers for org context, and the Salesforce CLI for testing and deploying. The author argues that coding agents drift from platform best practices and miss what already exists in an org, so a team should wrap them in its own project layer of skills, instructions, ontology, tools and checks. The linear project model becomes a loop in which each stage leaves an artifact for the next, and every mistake feeds back into the project. The author also stresses keeping the agent’s context lean, since accuracy falls as the context window fills, and notes that the agent’s built-in harness is the same for everyone while the project harness is what makes it effective on a specific org.
The seven stages run as follows. Ground gives the agent the org’s existing metadata through the read-only Metadata Grounding MCP Server (Beta), a feature map and an ontology of business terms. Specify has the agent produce a short, human-approved spec kept up to date alongside the code, recommended as spec-anchored and used only for features that span several metadata types or sessions. Build lets one agent work step by step, or subagents work in parallel in separate git worktrees, with each subagent given only the context it needs. Verify runs independent checks such as Apex tests, Code Analyzer, ApexGuru scans, LWC and accessibility checks, and hooks that run automatically. Review uses a separate, read-only adversarial reviewer agent whose findings humans judge. Release has the agent validate and promote changes through deterministic gates, with a human owning the production step. Observe has the agent read debug logs and traces to find production issues and start the next loop.
The post closes with a principle: each repeated mistake should become a constraint. Advisory instructions and skills reduce errors, but deterministic tests, Code Analyzer rules, hooks and quality gates catch them regardless of who wrote the code, and the author recommends choosing the strongest option available and cleaning up existing code that the agent might copy. The author presents this as one approach to adapt rather than the only way, and suggests installing the skills and starting with the stages that suit the team.
You will learn how to count orphaned Contacts, unresolved AccountIds, duplicate External IDs and picklist values outside the allowed API names, using spreadsheet formulas, a standard-library Python script and SOQL.
Why read this
The article also explains what these checks cannot catch.
Export Contacts and Accounts
Flag blank and unresolved AccountIds
Find duplicate External IDs
Compare picklist to allowed API names
Four checks run on the exported files after a load
A successful Data Loader insert or upsert can still leave a Contact export with problems the success file does not show. The article covers blank AccountIds, AccountIds that point to no Account in the export, External IDs shared by more than one Contact, and picklist values that are not among the field’s allowed API names.
The walkthrough works through example files and three methods: spreadsheet formulas that flag each problem column, a Python script using only the standard library, and SOQL queries to confirm the counts against the live org. It notes that SOQL returns picklist API names rather than labels, and that values loaded into an unrestricted picklist can be stored without being listed in Setup.
The author stresses that orphans are a review list rather than a delete list, and that a wrong but existing AccountId needs a separate source-to-target comparison. The example data is fabricated and the reader must adapt field headers to their own org.
You will learn a spreadsheet-based method for proving a Salesforce data migration is complete and accurate, using external keys, SOQL counts and totals, and case-sensitive value comparisons.
Why read this
You will also see how to tell nulls and truncation apart from other mismatches.
Reconcile record counts per object
Compare totals on amount fields
Compare field values on an external key
Sign off each object
The migration check runs in four steps, from counts to sign-off
A load that finishes without errors only shows that Salesforce accepted the rows sent to it. It does not show that every source record arrived or that the values arrived unchanged. The article sets out a check per object that compares record counts with SOQL, excluding records created by hand in the sandbox and records left out on purpose, and reports the difference in a status column.
Count matches are not enough on their own, so the author compares summed amounts per object and per StageName group, including the handling of corporate-currency totals in multi-currency orgs. Field values are then matched on an External ID using INDEX and MATCH, with EXACT used for a case-sensitive comparison and a sample taken for large objects. Nulls and truncation are flagged separately, because they have different causes and fixes.
The article closes with a per-object sign-off table that can only read Ready when counts, totals and value checks all pass, with a Counts only status for objects whose values have not been checked. The formulas were tested in LibreOffice Calc and are noted as untested in Excel and Google Sheets.
You will see how Apex tests can run on a CI runner against a local runtime, what a gated deploy with a check-only validation looks like, and the trade-offs of keeping the org only for the final deploy.
Why read this
The piece is also a product pitch for renmy, so weigh its benchmark claims accordingly.
Run local runtime gates on the bundle
Check-only validation of the same bytes
Deploy to the target org
The gated deploy sequence renmy deploy follows before any metadata reaches the org
The piece argues that most Salesforce CI pipelines waste time and reliability on provisioning a Scratch Org or shared sandbox just so Apex tests have somewhere to run. Its proposed alternative is renmy runtime, a local Apex runtime that executes Apex, SOQL, DML and Salesforce Flows on the CI runner itself, backed by an embedded PostgreSQL database. The author says this removes the need for a JWT certificate, a Dev Hub allocation or a Scratch Org for the unit-test job, and that tests finish in seconds with JUnit XML and Cobertura coverage output. The runtime is presented as an interpreter that enforces governor limits and platform rules, not a mock framework or a transpiler. The piece includes a GitHub Actions example in which the only secret needed is a license key, and it notes that tests can keep running during a Salesforce incident even though deploys cannot.
The piece also describes a gated deploy command, renmy deploy. It snapshots the source into a content-addressed bundle, runs the local test and coverage gates against those exact bytes, then runs a real check-only validation of the same bytes in the target org, and deploys only after that succeeds. A coverage floor can be set with a minimum-coverage flag. For teams that need an approval step, a release command validates and writes a receipt containing the bundle digest, git revision, org fingerprint, gate results and validation job id. After approval, a deploy step quick-deploys the validated job within Salesforce’s 10-day window, or resends the stored bundle, and rejects changed, expired or wrong-org receipts. The author also covers pinning the Salesforce CLI version and recovering deploys stuck in the org’s Pending queue.
The author is candid that the org still matters for anything a person inspects, for integration tests against real endpoints, and for the final validation and deployment. The main claim to weigh carefully is the vendor’s own benchmark: about 1 minute 46 seconds to deploy and run 837 tests in an org against 2.4 seconds locally, roughly 45 times faster, with all tests passing in both. The method is published by the vendor and has not been independently verified in the piece. Branch coverage is reported locally but not by the org, so the two coverage figures are not directly comparable. The piece also notes that the Team tier, which covers CI runner use, is free during the public beta, with a listed price of $49 per developer per month, and that an individual Free tier exists.
You will learn how to normalise legacy keys, count duplicates in a spreadsheet and in SOQL, separate true duplicates from key collisions, and repoint child records before deleting a duplicate Account.
Normalise the legacy key
Count raw and normalised keys
Classify each duplicate group
Repoint child records
Delete the duplicate
The duplicate clean-up sequence for migrated Accounts
Matching record counts after a migration can hide duplicates. Re-run loads, insert calls used where an upsert on an External ID was needed, and keys that differ only by case, spaces or leading zeros all leave duplicates behind. Salesforce duplicate and matching rules do not examine a legacy key unless a rule is built for it.
The article walks through normalising the key with spreadsheet formulas, counting raw and normalised keys, and classifying each group as unique, exact duplicate, hidden duplicate or key collision. A SOQL GROUP BY query with HAVING clause provides the same check inside the org, though it catches case differences only, not leading zeros or trailing spaces.
Before deleting anything, the author chooses a survivor, usually the Account with the most Contacts, and repoints Contacts, Opportunities and Cases to it with Data Loader or the Account merge operation. The checklist ends with marking the External ID field Unique so the next load cannot insert the same key twice.
You will learn how to measure governor limit consumption in Apex tests, set per-context budgets, and close the loop so AI agents fix limit-heavy code before it merges.
Why read this
The post includes a snapshot class pattern, a limits table and a retry-and-escalation design.
Agent pushes code with bulk tests
CI measures limit consumption
Breach sends feedback to agent
Up to two refactor attempts
Human architect review if still failing
How the CI loop handles a governor limit breach in agent-written code
The article argues that AI-generated Apex can be functionally correct and fully unit-tested yet still exhaust shared transaction budgets, because agents build each feature in isolation and small additions compound until a governor limit is breached. Standard small-data tests rarely expose this, and since governor limits are platform capacity ceilings, the author recommends treating them as architectural contracts and enforcing them automatically before code merges. It illustrates the compounding with a sprint-by-sprint example where SOQL consumption climbs from 15% to 59% through individually harmless changes.
The proposed approach has several parts. Teams should supply a shared, immutable GovernorLimitSnapshot test utility, require agents to write bulk tests of 200 records that capture before and after snapshots, and have CI verify that these test conventions are present. A table compares synchronous and asynchronous limits, and a budget-allocation table recommends consumption thresholds by execution context: roughly 40 to 50% for trigger code, 60 to 70% for service classes, 80 to 85% for isolated asynchronous jobs, and 20 to 30% for Scheduled Apex. Snapshots should be taken just before Test.stopTest() so the synchronous footprint is measured separately from asynchronous work, which is tested in its own method.
The article then describes a closed feedback loop in CI. When a test breaches its budget, a structured prompt containing the metric, consumption, threshold and required optimization steps goes back to the agent, which gets up to three attempts, with the delta between attempts supplied on later tries. If the third attempt fails, the merge is blocked and a human architect is asked to review, possibly moving the logic to Queueable. Agents must not be allowed to weaken tests or thresholds, and the author notes that some limits, such as callouts and Platform Event publishing, need production monitoring as well. Thresholds should start generous, use warning and violation tiers, and be tightened over time, with a closing checklist for rolling the pattern out.
You will learn how to test whether Contacts still point to the correct Account after a migration, using External ID keys, a child-to-parent SOQL export, and a source-to-target comparison.
Why read this
The method works with native tools and needs no third-party code.
Confirm keys are unique
Export Contacts with parent key
Match Contacts on their key
Compare Account keys
The wrong-parent check compares Account keys for each Contact across two orgs
Record Ids usually change between orgs, so comparing AccountId values across a migration tells you nothing. The article proposes a stable External ID on both Account and Contact, then checks that the parent Account’s key is the same on each side for every Contact.
The workflow starts with uniqueness and blank-count queries on the keys, then uses a single child-to-parent SOQL export from Contact via Data Loader to pull Account.External_Key__c onto each row. The same view can be built as a Contacts & Accounts report. Rows are then matched on the Contact key and the Account keys compared, with blanks flagged as unresolved and missing rows reported separately.
The author notes limits: the method needs a shared stable key, Data Loader does not support nested subqueries, and a clean parent check does not validate field values, sharing or record types. The article is written by the vendor of a paid CSV comparison tool, which it discloses.
You will know where Apex source, test data and licence details go when renmy runtime runs, which settings turn telemetry off, and how it works offline and air-gapped.
Why read this
It is the questionnaire answers a security or procurement team will ask for.
Org-based test runs
Each test run deploys to a Salesforce org
Test data sits in the org sandbox
Each developer needs an org credential
Local runtime
Tests run on the developer's machine
Test data lives in an in-process database
Test runs need no org or credential
Where Apex runs and where data lives, before and after a local runtime
This vendor-written piece, published by Renmy UG of Berlin, gives security and procurement teams the answers they need for a questionnaire about renmy runtime, a local Apex runtime formerly called Nimbus. It executes Apex, SOQL, DML and Salesforce Flows on a developer’s machine against an embedded PostgreSQL, without an org, Docker or a JVM. Apex source is read locally and sent to no one. Tests run against schema read from the project’s metadata, so they need no connected org, and test data sits in an in-process database with no open network port, rolled back after each test.
The article then sets out what leaves the machine. The Free tier needs no network access. By default the runtime sends one privacy-minimal activation event to an EU-hosted service, which excludes code, paths, test names and record data. Pro licences also record one de-duplicated activation from headless CI. Either can be switched off with a single setting or environment variable. Pro and Team licence checks send the licence key to the Keygen licensing API, at most once a day. Activating a machine with renmy login also sends a hashed installation ID, hostname, display name, OS, architecture, CPU core count and account ID. Licences are cached for offline use for up to seven days.
For disconnected networks, the article says the binary can be copied into place without internet access, since the database engine is embedded, and the daily update check can be disabled. Enterprise customers can have licence validation on premises, with pricing from $20,000 a year. A command-by-command table lists what each command contacts. The Salesforce org remains the system of record and deployment target. The deploy flow validates the same payload in the org before deploying, and Pro release commands produce signed receipts for auditors.
The piece closes with a list of documents to attach to the questionnaire, including the security page, data processing addendum, subprocessor list and licence terms. It also gives pricing: Free at $0, Pro and Team free during the public beta with listed prices of $19 and $49 per month, and Enterprise on a custom contract.
You will learn how a raw List parameter in an @InvocableMethod crashes the Apex language server and disables member completion in the file, which signature shapes trigger it, and how the author's VS Code extension detects and fixes them.
Raw List in @InvocableMethod
Server logs IllegalArgumentException
Completion lost across the whole file
Shape not checked against element type
Raw List in plain method
Only a syntax error is reported
Completion keeps working
Harmless, so not flagged
Raw List parameters break completion in invocable methods but not in ordinary ones
The author wrote an @InvocableMethod with a raw List parameter and found that member completion stopped working throughout the class, while the Problems panel showed only a generic syntax error. The cause is an exception inside jorje, the Apex language server in the Salesforce Extension Pack. For invocable, static @AuraEnabled, @Http and global methods, the server unwraps the element types of collection parameters and expects exactly one type argument, so a raw List produces an empty list and the check fails.
To separate harmful shapes from harmless ones, the author ran the language server headless against 274 signatures and recorded whether it logged an exception and whether completion came back empty. A raw List in an invocable method crashed the file, as did List, unfinished forms and wrong argument counts. A raw List in an ordinary method was only a syntax error with completion intact, and Set and Map in invocable methods were clean. A raw collection as a return type makes the parser drop the method, which limits the damage to that method.
The author’s extension, Virga, flags only the shapes that broke, using two diagnostic codes, and offers quick fixes that insert a type such as List chosen from the file. After applying the fixes, the server stopped throwing in all 184 breaking cases and completion returned in 180 of 181 where it had failed.
You will learn how to split one Apex test suite into parallel slices across CI runners, how classes are balanced by recorded duration, and when sharding is not worth the overhead.
Why read this
The article gives a working GitHub Actions matrix and explains how to merge the JUnit results.
Balance classes by recorded duration
Run each slice on its own CI job
Merge the shard JUnit XML results
Sharding assigns each test class to exactly one runner, then the results are merged
The article explains how to split one Apex test suite into parallel slices across CI runners using renmy runtime, a local Salesforce Apex runtime from Renmy UG that runs tests on the CI machine against an embedded PostgreSQL instead of in a Scratch Org or sandbox. The author argues that sharding was impossible in an org-based workflow, because every extra runner would need its own org, deploy and place in the org’s test queue. With a local runtime, the command renmy test –shard N/M runs one slice of the suite, and the wall-clock time falls to roughly the slowest shard plus setup, though total compute rises slightly. The runtime was previously called Nimbus, and the author notes that this is the same tool under a new name.
Sharding works at the level of whole test classes, so each class’s @testSetup runs once and its records remain consistent with an unsharded run. Classes are balanced using durations recorded in .nimbus/test-durations.json, and projects without that history fall back to an even split by class name. Because each shard computes the partition independently, every job must see the same durations file, which the author recommends committing or restoring from a cache. The article supplies a GitHub Actions matrix with fail-fast disabled, a per-shard JUnit file, and an always-run publishing step. It also shows how to merge results either through the shard attribute that the JUnit XML carries or by uploading artifacts and publishing them from a job that runs after the matrix.
The piece also covers coverage and caching. A shard measures coverage only for the tests it runs, so whole-suite coverage needs a single process, and the article points to renmy deploy –min-coverage and renmy coverage diff for gating. Shards can share a cache of parsed ASTs and the binary to reduce cold-start time.
Finally, the author warns that sharding is not worth its overhead for suites that finish within about a minute, since each shard repeats checkout, installation and database startup. Alternatives suggested first are parallel workers within one job, caching, and an external PostgreSQL service container. Sharding is recommended when the test step alone runs for several minutes. A slow class sets a floor on its shard’s time, and order-dependent tests can surface when classes move between shards. Running on a CI runner belongs to the Team tier, which is free during the public beta, and JUnit and Cobertura output are Pro features.
You will learn how a committed renmy.properties file and a local Apex runtime let a new developer run the full Apex test suite on day one without an org.
Why read this
You will also see the same command reused in CI, with its trade-offs.
Clone the repository
Install renmy runtime
Run renmy doctor
Run renmy test
Day one with a local Apex runtime takes four steps, none of which needs an org
The article argues that onboarding a Salesforce developer usually means waiting days for a sandbox, a user, a Permission Set and VPN access before the first Apex test can run. It presents renmy runtime, a local Apex runtime made by Renmy UG in Berlin, as a way to skip that wait. The tool executes Apex, SOQL, DML and Salesforce Flows on the developer’s machine against an embedded PostgreSQL, ships as one binary for macOS, Linux and Windows, and needs no org, Scratch Org, Docker or JVM. The author says governor limits are enforced and each test runs in its own transaction, and cites a public benchmark in which 837 tests ran roughly 45 times faster locally than in an org.
The article walks through a four-step day one: clone the SFDX repository, install the binary with a one-line script (or let the IntelliJ plugin or VS Code extension handle it), run renmy doctor to check the project layout, and then run renmy test “” or narrow it to a class or method. The test environment lives in a renmy.properties file that the team lead generates with renmy config init and commits to the repository. That file sets org defaults such as currency, locale and timezone, seeds Custom Settings so code reading getOrgDefaults() works without @testSetup, and defines a stricter ci profile. Permission Sets load from metadata already in the repository.
Some gaps still need attention. Managed packages whose source is hidden need stubs pulled once by someone with org access and then committed, and multi-currency orgs need a feature flag. The doctor output and failure traces name missing pieces, so closing a gap in the repository helps every later developer. Org access remains necessary for deployment and browser-based work, so the access request still goes in on day one but is off the critical path. The same renmy test “” command runs in CI with the ci profile and needs no connected org, though it requires a license key secret. The Free tier costs nothing per developer for one machine, while the Team tier adds CI runs and seat management, is free during the public beta, and lists at $49 per developer per month. The article concludes that sandboxes remain the right place for UI work and deployment.
You will learn how to run Record-Triggered Flows and Apex triggers on a local machine, catch order-of-execution overlaps before activation, and what the runtime does not cover.
Retrieve flow into project folder
Write test creating and closing record
Run renmy test locally
Fix overlap, rerun in seconds
Activate and review in sandbox
A local test run replaces repeated sandbox rounds for checking flow and trigger behaviour
renmy runtime, formerly called Nimbus until its October 2026 rename, is a local Salesforce Apex runtime. It executes Apex, SOQL, DML and Salesforce Flows (Autolaunched, Record-Triggered and Screen Flows) on a developer’s own computer against an embedded database, with no org, sandbox or Scratch Org involved. The article argues that testing flows in a shared sandbox is slow and risky: other people’s automation fires alongside yours, test data disappears after refreshes, and overlaps between a flow and an Apex trigger on the same object often surface only after activation. Running locally, a Record-Triggered Flow fires together with the object’s triggers in the platform’s order of execution, so overlaps show up in milliseconds.
The article walks through an example: a Record-Triggered Flow that creates a follow-up Task when an Opportunity is set to Closed Won, alongside an older Apex trigger that also creates a Task. A developer retrieves the flow file into the project folder with the Salesforce CLI. They then write a short Apex test that creates an Account and an Opportunity, moves the stage to Closed Won, and asserts that exactly one Task exists with the expected subject. The admin can read that test as an acceptance criterion. Running renmy test with the test name, or with “” for every test, reports the result. If the trigger also creates a Task, the assertion fails with two Tasks, revealing the overlap. The fix is either to remove the trigger’s logic or to add an entry condition to the flow, and the rerun takes about a second. Once the flow is ready, renmy deploy runs the local checks before anything reaches the org.
The same runtime is available through a browser-based Dev UI started with renmy dev, which offers a test runner, schema browser and coverage explorer. A VS Code extension adds run buttons above each test, and a JetBrains plugin does the same in IntelliJ IDEA, including its Community edition, and can display a flow as a graph. The article is clear about the limits. The runtime executes a Screen Flow’s logic but does not render its screens, so layout, labels and conditional visibility must be checked in a sandbox with a user. It reproduces platform rules closely but is not Salesforce itself, and permissions, page layouts and user acceptance still require an org. The Free tier includes unlimited local test runs on one machine, with no account or card required.
You will learn why coding agents stall on Apex when every test run needs a Salesforce org, and how a local Apex runtime exposed through an MCP server gives an agent a fast write-run-fix loop.
Why read this
You will also see the boundary the article draws around deployment.
Against an org
Deploy class to an org
Wait, then start test run
Poll until finished
Minutes per cycle
Against a local runtime
Run tests on the machine
Read structured results
Fix and rerun
Seconds per cycle
Agent loop against a Salesforce org versus against a local Apex runtime
The article argues that AI coding agents stall on Salesforce Apex because Apex only runs inside a Salesforce org, so each test cycle means deploying, waiting, polling and parsing logs, which can take minutes and requires org credentials. Agents then either stop iterating and hand back untested code, or keep going at a high cost in time and tokens. The author’s published benchmark puts four open-source Apex suites, 837 tests in total, at about 1 minute 46 seconds to deploy and run in an org, against 2.4 seconds locally. The piece also notes that Nimbus was renamed renmy runtime in October 2026, with the same binary and the MCP server name nimbus kept.
The proposed fix is renmy runtime, a local Apex runtime that executes classes, triggers, SOQL, DML and Salesforce Flows against an embedded PostgreSQL, with no org, sandbox, Docker or JVM. The author says it enforces governor limits and mirrors platform behaviour such as Test.startTest and Test.stopTest, and that it is not a mock or a transpiler, though it does not achieve perfect parity. Its renmy mcp command runs as a stdio child process of the agent, so no port or credential is needed. The exposed tools include run_apex_tests, explain_failure, get_coverage, get_execution_trace, execute_anonymous and list_test_classes, which return structured results rather than logs to parse. Setup is a one-line install, a test run in the project, and registration with Claude Code, Cursor or GitHub Copilot.
A worked example shows an agent adding a discount rule to an invoice service: it lists existing tests, writes a method and test, runs the suite, uses the failure explanation to find a status filter bug, fixes it, and uses coverage to add a boundary test, all within seconds and without touching an org. The author also connects this to Salesforce Headless 360, where Apex hooks such as InvocableMethod and RestResource become tools for Agentforce or external agents, and says the runtime can test that underlying Apex offline.
The article draws a firm boundary around deployment. A green local run is necessary but not sufficient, because the org holds Permission Sets, managed packages, Validation Rules and other teams’ automation that a repository does not contain. The agent should not deploy on its own. renmy deploy runs local gates, then a real check-only validation in the org before deploying, while renmy release validate and renmy release deploy add a human approval step and an immutable receipt between the two. The Free tier covers unlimited local test runs, and the MCP server is a Pro feature that is free during the public beta.
You will learn what renmy runtime does, how it runs Apex and Flows locally against an embedded PostgreSQL, and which commands cover testing, debugging, AI agent integration and gated deploys.
Why read this
You will also see what the benchmark claims and what sits behind the Pro tier.
Snapshot selected source into a bundle
Run local validation and test gates
Check-only validation in the target org
Deploy the validated bundle
The gated deploy path from local source to the Salesforce org
Nimbus has been renamed renmy runtime, with the same tool and the same binary. It is a local Salesforce Apex runtime that executes real Apex, SOQL, DML and Salesforce Flows on a developer’s machine against an embedded PostgreSQL database. The runtime enforces platform rules such as governor limits, order of execution across triggers and flows, and per-test transaction isolation. It ships as a single binary for macOS, Linux and Windows and needs no org, Scratch Org, Docker or JVM.
The article’s benchmark compares four open-source Apex suites containing 837 tests. Run in a Salesforce org, they took about 1 minute 46 seconds, and locally they took about 2.4 seconds, roughly 45 times faster, with every test passing in both places. Around the runtime sit a language server that serves editors such as VS Code, Cursor, Neovim, Zed and JetBrains IDEs, a live debugger that supports breakpoints and stepping, and line and branch coverage reporting. Pro adds mutation testing, which the author says is the first of its kind for Apex, and watch mode. The toolkit also includes failure explanation and triage tools, a browser-based Dev UI, and a flaky-test finder.
For AI coding agents, renmy provides an MCP server with tools for running tests, executing anonymous Apex, reading coverage and explaining failures, so agents can verify Apex locally before anything reaches an org. The deployment path is gated: renmy deploy is free and snapshots the source, runs local tests and coverage gates, validates the same bytes in the target org with a check-only validation, and then deploys. The Pro renmy release commands split validation from deployment and produce a receipt that records the bundle digest, Git revision, gate results and the validation job ID, so a team can approve and deploy the validated payload from another machine. The article stresses that Sandboxes remain useful for end-to-end checks and user-facing testing.
The Free tier costs nothing without a card and covers unlimited local test runs, gated deploys, Salesforce CLI pass-through and IDE integrations on one machine. Pro, which adds the daemon, parallel runs, debugger stepping, mutation testing and the MCP server across three machines, and Team are both free during the public beta. Their list prices are $19 per month and $49 per developer per month, and Enterprise starts at $20,000 per year.
You will learn a design for letting an AI agent handle Salesforce deploys safely: a fixed action menu, approval gates, org-checked results and logged, capped runs.
Why read this
The reader comes away with a concrete set of guardrails to consider.
Plan reviewed and approved
Check-only validation in production
Human clicks to deploy
Org queried to verify results
The agent works through three human approval gates before production changes
The author argues that the slow part of a Salesforce deploy is usually assembling the package, choosing tests and target org, and interpreting failures, which are language tasks suited to a model. Deployment itself is not, so the agent is designed around four rules.
First, the model never touches an org. It receives no credentials, shell or sf CLI access, only a fixed menu of actions such as validate, deploy, run tests, query and retrieve. Code checks its parameters and performs the action with the sf CLI and git.
Second, humans approve at three points: the plan, which shows components, target org, tests and risk; a changed plan, when a retry alters components or scope; and production, where a check-only validation runs before a human deploys, including destructive changes. Sandbox steps run automatically while everything stays green. Third, success is verified by querying the org, not taken from the model, and the summary is written from that evidence table. Fourth, every run is logged, with a cost cap and a limit of three retries.
The model’s role is limited to turning a request into a reviewable plan and turning a failed deploy into a plain explanation, such as a test that does not set a new checkbox and so trips a new Validation Rule.
You will learn how the renmy runtime JetBrains plugin runs Apex tests and debugs Apex locally in IntelliJ IDEA, what it needs, and how it fits alongside an org-based workflow and Illuminated Cloud.
Org-based workflow
Save and deploy to an org
Wait for the test to run
Download and read a debug log
No breakpoints to stop on
Local runtime workflow
Run icon beside each test
Tests run locally in under a second
Native debugger with breakpoints
Consoles run against local data
Apex work with and without a local runtime in IntelliJ IDEA
The JetBrains plugin formerly listed as “Nimbus - Local Apex Runtime” is now Renmy Runtime - Salesforce IDE, version 1.15.1, following the October 2026 rename of the underlying runtime to renmy runtime. The article presents it as a way to bring a local Apex runtime into IntelliJ IDEA Community or Ultimate. The runtime executes Apex, SOQL, DML and Salesforce Flows on the developer’s machine against an embedded PostgreSQL, without needing a Salesforce org, Scratch Org, Docker or a separate JVM. The author argues that Apex developers have never had the gutter run icons, breakpoints and local consoles that Java developers take for granted.
Setup is short. The plugin installs from the JetBrains Marketplace, and on first open of a project containing sfdx-project.json it installs its runtime into ~/.nimbus/bin. The Free tier needs no account. Each @IsTest class and method gets a run icon and Run, Debug, Coverage and Trace lenses, and results stream into IntelliJ’s test tree with time and SOQL and DML counts per method. The plugin uses the same backends as the CLI, so a test that passes in the IDE should pass under renmy test in a terminal or CI. Debugging uses a native session with breakpoints in .cls and .trigger files, and a replay mode that can step backwards through a recorded run. Recording is free, while stepping is Pro and free during the public beta. The article points to a public parity record and a benchmark, which reports 837 tests running in about 2.4 seconds locally against roughly 1 minute 46 seconds in an org.
The tool window groups features into six workspaces: Home, Develop, Org, Verify, Release and Admin. Develop holds Apex and SOQL consoles that can target the local runtime or any org the CLI is logged into, along with Run and Compare and Find in All Orgs. Org covers browsing, drift detection, debug-log replay and a Data Loader that simulates CSV loads locally and reports rejected rows before any upload. Editing adds sixteen inspections, refactorings, generators, live templates and metadata shown as forms. Previews render React, LWC and Visualforce, though only 25 of 77 Apex: components are drawn fully.
The plugin is described as working alongside Illuminated Cloud. Its shortcuts sit in the Alt+Shift namespace to avoid collisions, and a Tools → Renmy setting decides which Apex file types it keeps when Illuminated Cloud is installed. The article presents the local loop as complementing a sandbox rather than replacing it, with renmy deploy validating the same code in the org before deploying. The Free tier is $0 for one machine, while Pro is free during the beta and listed at $19 a month afterwards.
You will learn which login pages change and when, what stays the same for passkeys and MFA, and what admins should do about users, shared inboxes and automated UI tests before the rollout reaches production.
Enter the email address
Receive a verification code by email
Choose the org in the environment switcher
Or click Login with Username
Login order on login.Salesforce.com once email becomes the default
Salesforce has announced that the login pages at login.Salesforce.com and test.Salesforce.com will ask for an email address first, with username login still available through a Login with Username link. The change was first described in the Spring ’26 release notes and was communicated to admins by email in September. Sandboxes are scheduled for August 2026 and production for October 2026, while mobile apps are tentatively planned for late 2026. My Domain and Experience Cloud login pages are not affected.
The article notes that a username-first experience is also being rolled out on My Domain login pages, and that Salesforce describes passkeys as the fastest, easiest and most secure way to sign in. Salesforce’s stated reason for email login is a unified login process in which a user types one email and sees every org they can access. The author could not find a clear security rationale for the change. Email login sends a verification code, and the environment switcher lists the matching orgs. Problems arise when a user’s email and username differ, or when one email maps to several usernames.
The community is split. Supporters find the flow smooth and note that passkeys reduce clicks. Consultants and partners with many orgs find the extra selection step costly. An IdeaExchange request asking Salesforce not to make email the default has gathered 760 points, arguing that an email lookup can reveal every environment tied to it. Salesforce said at True to the Core that email login still requires access to the inbox, and that it is working on auto-favoriting login hints for multi-org users. The article’s advice is to check for shared inboxes, tell users to use the My Domain URL, and add ?login=1 to automated test URLs so they reach the username screen.
You will learn how to create a Claude Code mod that reads Salesforce CLI configuration files to show your default org, its type, and Scratch Org expiry directly above the command prompt.
Why read this
The guide covers the required plugin structure, event hooks, and testing steps.
The article walks through creating a custom plugin for Claude Code that surfaces Salesforce CLI context directly in the terminal interface. It explains how to set up the plugin manifest, define reactive state types, and structure the directory for hooks and tests.
Instead of running slow CLI commands, the mod reads internal Salesforce authentication and configuration files to determine the target org alias, My Domain, org type, and Scratch Org expiration date. It also tracks which organizations are connected to configured Salesforce MCP servers.
The tutorial details several event hooks that trigger when sessions start, directories change, or tool calls execute. A render hook draws a colored status band above the prompt, using theme-aware colors to distinguish production, sandbox, and Scratch environments. The author includes validation and testing procedures, plus instructions for making the plugin load automatically across sessions.