Your daily Apex work, running locally

// AccountTrigger.trigger
trigger AccountTrigger on Account (before insert) {
    for (Account acc : Trigger.new) {
        if (acc.Industry == null) {
            acc.Industry = 'Other';
        }
    }
}

// AccountTriggerTest.cls
@isTest
private class AccountTriggerTest {
    @isTest
    static void testDefaultIndustry() {
        Account acc = new Account(Name = 'Acme');
        insert acc;

        Account result = [SELECT Industry FROM Account
                          WHERE Id = :acc.Id];
        System.assertEquals('Other', result.Industry);
    }
}

@isTest
private class BulkOperationsTest {
    @isTest
    static void testBulkInsert() {
        List<Contact> contacts = new List<Contact>();
        for (Integer i = 0; i < 200; i++) {
            contacts.add(new Contact(
                FirstName = 'Test',
                LastName = 'Contact ' + i,
                Email = 'test' + i + '@example.com'
            ));
        }

        Test.startTest();
        insert contacts;
        Test.stopTest();

        List<Contact> results =
            [SELECT Id FROM Contact];
        System.assertEquals(200, results.size());
    }
}

@isTest
private class QueryTest {
    @testSetup
    static void setup() {
        Account acc = new Account(
            Name = 'Acme Corp',
            Industry = 'Technology'
        );
        insert acc;

        insert new Contact(
            AccountId = acc.Id,
            FirstName = 'Jane',
            LastName = 'Doe'
        );
    }

    @isTest
    static void testRelationshipQuery() {
        String industry = 'Technology';
        List<Account> accs = [
            SELECT Name,
                (SELECT FirstName, LastName
                 FROM Contacts)
            FROM Account
            WHERE Industry = :industry
        ];

        System.assertEquals(1, accs.size());
        System.assertEquals(1, accs[0].Contacts.size());
    }
}

@isTest
private class OpportunityFlowTest {
    @isTest
    static void testStageChangeFlow() {
        // Insert an opportunity - record-triggered
        // flows fire automatically on DML
        Opportunity opp = new Opportunity(
            Name = 'Big Deal',
            StageName = 'Prospecting',
            CloseDate = Date.today().addDays(30),
            Amount = 50000
        );
        insert opp;

        // Update stage - triggers the "Opp Stage Change"
        // record-triggered flow (before save)
        opp.StageName = 'Closed Won';
        update opp;

        // Verify the flow's assignments executed
        Opportunity result = [
            SELECT StageName, Description
            FROM Opportunity WHERE Id = :opp.Id
        ];
        System.assert(
            result.Description.contains('Closed Won'),
            'Flow should have updated description'
        );
    }
}

# .github/workflows/apex-tests.yml
name: Apex Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Nimbus
        run: |
          curl -fsSL https://install.testnimbus.dev | sh

      - name: Run Apex tests
        run: |
          nimbus test \
            --coverage --coverage-report coverage.xml \
            --results-xml results.xml

      - name: Upload to Codecov
        uses: codecov/codecov-action@v4
        with:
          files: coverage.xml

      - name: Publish test results
        uses: dorny/test-reporter@v1
        with:
          name: Apex Tests
          path: results.xml
          reporter: java-junit

# VS Code Extension - install from Marketplace: "Nimbus Apex"
#
# Run tests:
#   CodeLens "Run Test" / "Debug Test" above every @isTest method
#   Test Explorer panel: full test tree, pass/fail, timing, inline errors
#
# Code intelligence:
#   Coverage gutter icons - green / red / yellow per line
#   Governor limits view - color-coded usage bars per test
#   SOQL preview - hover any query to see translated SQL
#   Trace viewer - call tree + timeline waterfall + filterable log
#
# Productivity:
#   Schema explorer - browse objects, fields, relationships
#   Execute Anonymous - run any Apex without a test class
#   Watch mode - tests re-run on save, results appear inline
#   Test history - trends, flaky detection, run comparison

# IntelliJ IDEA Plugin: same feature set - coming soon.
# Both editors talk to the same Nimbus daemon.

# Dev UI (browser dashboard):
nimbus dev
# → http://localhost:7890
# → Real-time results with live WebSocket updates
# → Coverage summary with per-file breakdown
# → Schema explorer with row counts
# → Execute Anonymous with structured output

# Prerequisite (one-time, per team):
# All metadata must be in the repo.
# Retrieve everything from the org:
sf project retrieve start --target-org YourOrg
git add . && git commit -m "chore: retrieve all org metadata"

# During development, if a test references metadata
# that isn't in the repo yet, Nimbus fetches just
# what the tests need and re-runs automatically:
nimbus test --fetch-missing -o YourOrg

# ---

# Day 1 for every new developer after that:

# 1. Clone the repo
git clone git@github.com:your-org/salesforce-app.git
cd salesforce-app

# 2. Install Nimbus (one-time)
brew install nimbusdev/tap/nimbus

# 3. Initialize the local environment
nimbus init

# 4. Run the full test suite - no org access required
nimbus test

# 5. Start developing with instant feedback
nimbus test:watch

# Set breakpoints in VS Code and run:
nimbus test "AccountServiceTest.testBulkUpdate"

# When the breakpoint hits:
#   → See the full call stack
#   → Inspect local variables with types
#   → Expand SObjects to see all fields
#   → Expand collections to see every element
#   → Step In / Step Over / Step Out
#   → Continue to next breakpoint
#
# Step modes:
#   Step In    → Enter the next method call
#   Step Over  → Execute next line, skip internals
#   Step Out   → Run to return, pause in caller
#
# No deploy. No debug log levels. No Setup UI.
# Just breakpoints, like every other language.

# Run tests with tracing enabled
nimbus test "OrderProcessingTest.*" --trace

# Trace verbosity levels:
#   minimal  → Test/method boundaries only
#   normal   → DML, SOQL, exceptions, branches
#   verbose  → Variable assignments, loop iterations
#   debug    → Every evaluation step

nimbus test --trace --trace-level verbose

# Output: structured JSONL in .nimbus/traces/
# Each span includes:
#   - Span hierarchy (parent → child)
#   - Precise timing (microsecond resolution)
#   - SOQL queries with row counts
#   - DML operations with record counts
#   - Trigger execution with event type
#   - System.debug() output with source location

# Start watch mode
nimbus test:watch

# Nimbus watches your force-app/ directory
# for any .cls or .trigger file changes.
#
# When you save a file:
#   1. Changed classes are re-parsed (~10ms)
#   2. Affected tests are identified
#   3. Tests re-run automatically (<500ms)
#   4. Results appear inline
#
# Interactive controls:
#   [a] Run all tests
#   [f] Run only failed tests
#   [p] Filter by pattern
#   [q] Quit

// Your production code:
public Integer calculateDiscount(Integer quantity) {
    if (quantity > 10) {     // Mutant: change > to >=
        return quantity * 5; // Mutant: change * to /
    }
    return 0;                // Mutant: change 0 to 1
}

// Your test:
@isTest static void testDiscount() {
    Integer result = new PricingService().calculateDiscount(20);
    System.assertEquals(100, result); // Catches the * → / mutant ✓
    // But do you test the boundary at exactly 10?
    // Do you test that quantity <= 10 returns 0?
}

# AI agent workflow with Nimbus:

# 1. Agent generates or modifies an Apex class
#    → AccountTriggerHandler.cls updated

# 2. Agent runs tests locally
nimbus test "AccountTriggerTest.*" --json

# 3. Agent reads JSON results, spots the failure:
#    "Expected 'Technology', got null"

# 4. Agent fixes the handler, runs tests again
nimbus test "AccountTriggerTest.*" --json

# 5. All green - agent moves to next task
#    Total elapsed: ~15 seconds
#    With org testing: ~15 minutes