AI delivery standard
Learn how SRE.ai supports a governed, repeatable approach to AI-assisted Salesforce delivery
Overview
AI adoption in Salesforce delivery teams is often uneven.
Some individuals use AI tools independently, others don't. Outputs vary. There's no shared way to confirm that AI-generated work is correct before it ships, no audit trail of what the AI produced versus what a human approved, and no consistent set of guardrails across the team.
AI delivery standard is about making AI usage in delivery consistent and governable — so the whole team benefits from AI without losing control over what ships.
SRE.ai provides a structured delivery flow where:
AI work begins with a design phase that a human reviews and approves before implementation starts.
Agents surface their plans and intermediate artefacts at each step, so a team member can confirm the approach before the agent proceeds.
Every agent task is linked to a Change, creating a full audit trail of what was designed, built, reviewed, and deployed — and by whom.
Roles and permissions control who can trigger agents, approve designs, and promote changes through the pipeline.
Structured design-before-build flow
Scenario
Problem:
AI-generated implementations vary in quality. Without a mandatory design step, AI builds solutions that may be functional but not aligned with the org's architecture, existing patterns, or team standards.
When that happens, the team still needs a senior engineer to review and often rewrite the output — which eliminates the efficiency gain and creates inconsistency across the codebase.
SRE.ai's fit:
SRE.ai enforces a design-before-build sequence through the Design Agent and Build Agent. The Design Agent produces a structured plan that must be reviewed and approved by a team member before the Build Agent begins implementation. No code is written until a human has confirmed the approach.
This flow relies on SRE.ai's Agents feature. Read the Agents documentation for how the Design Agent, Build Agent, and Deploy Agent work and how their tasks are linked to Changes.
Who this is for
Teams that want to use AI in delivery but need consistent, reviewable output — not ad hoc generations that vary by individual.
Particularly useful for teams working across multiple orgs or projects where delivery standards need to hold regardless of who is doing the implementation work.
Click to learn how SRE.ai addresses this scenario
What you'll need
A connected GitHub repository (see Integrations documentation)
At least one connected Salesforce org (see Salesforce Orgs documentation)
Workflow
SRE.ai's Agents are activated in natural language from the Command Center. No special commands are required.
Step 1 — Design:
Open the Command Center and describe the change to implement.
The Design Agent activates. It explores the repository structure, examines relevant metadata in the org, and produces a design document containing:
Success criteria
Architecture and approach decisions
Implementation plan
Testing strategy
Risk notes
The design is created with a status of Draft.
A team member reviews the design and sets the status to Approved when the approach is confirmed.
If the approach needs adjustment, the design can be revised before approval.
Implementation does not begin until the design status is Approved.
Step 2 — Build:
With an approved design, activate the Build Agent from the Command Center.
The agent creates a feature branch, generates the required code and metadata following the repo's existing patterns, validates the result against the connected org, and commits the changes.
The agent surfaces its progress and artefacts as the task runs — branch created, files modified, validation result, commit reference.
The developer reviews the agent's output and the linked Change before promoting the work.
Step 3 — Deploy:
The Deploy Agent is activated from the Command Center to handle deployment.
The agent identifies the components to deploy, confirms the target environment, executes the deployment with validations, and reports the result.
All deployment activity is recorded on the linked Change.
Result
AI-generated work follows a consistent sequence: design → human approval → build → human review → deploy.
The team benefits from AI-assisted delivery without losing the review and approval steps that ensure quality and alignment with org standards.
Traceability and audit trail for AI-assisted work
Scenario
Problem:
When AI tools are used without a structured workflow, it's difficult to answer basic questions: who triggered this change, what did the AI generate, and did a human review it before it shipped?
Without that visibility, teams can't audit AI-assisted work or verify that their own delivery standards were followed.
SRE.ai's fit:
Every agent task in SRE.ai is linked to a Change, which records the full lifecycle — what the agent produced, which files were modified, commits, pull requests, quality findings, test results, and deployments — with timestamps and actor attribution throughout.
Traceability for AI-assisted work is provided through SRE.ai's Changes feature. Read the Changes documentation for an overview of what is tracked across the change lifecycle.
Who this is for
Teams that need to demonstrate that AI-assisted Salesforce changes followed a governed review and approval process before shipping.
Click to learn how SRE.ai addresses this scenario
What is recorded on every Change
SRE.ai's Changes feature records the following for every change that moves through the platform, including changes produced by agents:
Commits — every commit associated with the change, including those produced by the Build Agent.
Pull requests — PR status, reviewer activity, and merge outcome.
Code quality findings — static analysis violations, AI observations, and dependency checks, with resolution status and dismissal reasons.
Test coverage — per-class Apex test coverage against configured thresholds.
Deployments — deployment status, timestamp, target environment, and deployer.
Activity timeline — a chronological log of all significant lifecycle events with timestamps and actor attribution.
Design artefacts — design documents produced by the Design Agent, with their review status (Draft, Under Review, Approved, Implemented, Archived).
External issue links — linked Jira or Linear issues, synced throughout the lifecycle.
Example workflow
A team member activates the Design Agent to plan a Salesforce change.
The design is created as a Draft and linked to a Change. The reviewer sets the status to Approved — this action is logged on the Change timeline.
The Build Agent implements the approved design. Its commits and file modifications are recorded on the Change.
Automated code analysis runs on the committed work. Findings are surfaced, and resolutions or dismissals are recorded with reasons.
The change is deployed to production through the pipeline. The deployment event is logged with timestamp and deployer identity.
The full trail — design, build, review, and deployment — is available on the Change detail view at any time.
Result
Every AI-assisted change has a complete, auditable record: what was designed, who approved it, what was built, what was found during review, and when and by whom it was deployed.
Teams can answer audit questions about any change without reconstructing the history from separate systems.
Access controls for AI-assisted delivery
Scenario
Problem:
Not everyone on a team should have the same level of access to trigger agents, approve designs, or promote changes through the pipeline.
Without access controls, a developer could trigger a build without a reviewed design, or promote a change without the appropriate approval — bypassing the governance steps that make AI-assisted delivery safe.
SRE.ai's fit:
SRE.ai's role-based permissions model controls what each team member can do across Pipelines, Changes, and other platform features. Assigning roles based on responsibility ensures that governance steps — approving a design, configuring pipeline standards, promoting to production — are performed by the right people.
Access controls are configured through SRE.ai's Roles and permissions feature. Read the Roles and permissions documentation for the full permissions reference by role and area.
Who this is for
Teams that need AI-assisted delivery workflows to follow defined approval paths, with the right people responsible for each step.
Click to learn how SRE.ai addresses this scenario
What you'll need
Team members invited to the SRE.ai workspace
Roles assigned based on each member's responsibilities (see Roles and permissions documentation)
Role overview
SRE.ai provides three roles:
Owner — full access to all platform features, including pipeline management, stage configuration, and team administration.
Admin — all permissions except deleting pipelines. Suitable for delivery leads and senior engineers who configure standards but should not be able to delete production pipeline configurations.
Member — read-only access to pipelines and team settings. Suitable for contributors who execute delivery work within the configured standards.
See the Roles and permissions documentation for the full permissions breakdown by area.
Setup
Assign roles to reflect your team's delivery structure.
Navigate to Team settings and open the Members list.
Assign roles based on responsibility:
Owners or Admins: delivery leads, senior engineers, platform owners — those responsible for configuring pipeline standards and approving design artefacts.
Members: developers and admins executing delivery work within the configured standards.
Review role assignments as the team grows or responsibilities shift.
Result
Platform capabilities are accessible based on role, ensuring that governance steps — pipeline configuration, design approval, production promotions — are performed by the appropriate team members.
AI-assisted delivery follows defined paths without relying on individual discipline to enforce them.
Last updated