How Salesforce Engineering Became Truly Agentic - Salesforce

Skip to Content

Skip to Footer

0%

Key Takeaways

Autonomous tools are now writing code, reviewing pull requests (“PRs”), and driving deployments across the software development lifecycle.

Standardizing on Claude Code and removing token limits improved output and quality simultaneously — more shipped, fewer incidents, and fewer bugs.

An agentic workflow allowed a product team to complete a 231-person-day migration in 13 days — 18 times faster.

We’re still in the early stages of redefining how the roles across engineering, product, and design will change.

A few months ago, I wrote about the hard work of getting thousands of engineers to actually use AI — not just adopt it in name, but embed it meaningfully into how they work. We built the governance scaffolding, the measurement infrastructure, and the workflows to make it real. We crossed 90% adoption. That felt like a milestone.

It turns out, that was just the beginning.

Today, Salesforce Engineering is running on AI. We’ve moved from a world where AI was a helpful copilot to one where agentic tools are driving the software development lifecycle (SDLC) itself — writing code, reviewing pull requests (PRs), generating tests, updating documentation, managing deployments, and increasingly coordinating work that used to require significant human handoff. The change has been sharper and faster than anything I’ve seen in my career.

Here’s what that shift actually looks like, what drove it, and what it’s teaching us.

Ramping with Claude Code

The biggest inflection point was a deliberate, organization-wide pivot to Claude Code as our primary AI agent tool. We rolled it out to all of our engineers. Then we did something that sent an even clearer signal: we removed all token limits . Our primary directive was to remove every last piece of friction between our engineers and the tools that make them faster and more effective.

The results are showing up in the data. In April 2026, work items completed per developer are up 50.8% compared with April 2025. PRs merged per developer are up 79%. And most importantly, when we measure the true value of code delivered — not just the volume — using a machine learning-based Effective Output score , we’re seeing that output has grown 151.3% year over year.

What Agentic Transformation actually looks like

Numbers tell part of the story. But one example from our product teams tells it better.

The team faced a migration of 33 API endpoints to a new cloud-native architecture — the kind of task that, done the traditional way, would drain roughly 231 person-days, or seven per API. Manual schema mapping, manual testing, and manual documentation create massive friction, stalling momentum and trapping entire engineering teams in months of low-leverage toil.

They did it in 13 days. Eighteen times faster .

Here’s how: The team built a rule-based framework using Claude — markdown files combined with reference implementations — to standardize the AI-automated migration. Every round of PR feedback got incorporated back into the rule set, so accuracy improved continuously and outputs arrived near production-ready. They let autonomous large language model loops run (build, fix, validate) without manual intervention and parallelized migrations across isolated environments to generate multiple PRs simultaneously. Thirty-three endpoints. Five PRs. The largest single PR delivered 21 endpoints with 100% test coverage.

That’s a different way of building software.

More output, better quality — at the same time

The skeptic’s question when you push AI this hard is, what breaks?

Engineering 360, a platform that centralizes engineering data from hundreds of systems to track security, availability, quality, and developer productivity, has a clear answer: Quality went up: Even with the increase in PRs, total incidents dropped by 5%.

This matters because productivity and quality are often framed as a tradeoff. We’re not seeing that tradeoff. Trust is our #1 value, and our engineers are investing their AI superpowers to meet our highest quality standards and nonfunctional requirements. For example, we have embedded security guardrails and quality standards structurally into the agentic workflow. When agentic tools get applied properly, quality doesn’t suffer from speed. It benefits from it.

Rethinking the SDLC

Four months ago, we learned that AI had to fit into existing workflows for engineers to adopt it. Now that they’ve adopted it, they’re using AI to completely tear down and rebuild those same workflows.

Our engineers are fundamentally rethinking how they practice the SDLC. What processes can be removed entirely? What handoffs are unnecessary? Where are humans still doing work that an agent can own? Those are the questions that unlock real productivity — not marginal improvement. And it definitely doesn’t look like what we had before, with AI bolted on.

Skills, subagents,...