How Salesforce teams build and ship changes with Cam, the Gearset agent

Share with

Description

Using AI for Salesforce development helps your team build changes faster, but it moves the bottleneck rather than removing it. Every change still needs checking, testing, and releasing safely.

Tickets rarely tell the whole story, either. A missing detail today can turn into a problem you only find months later.

Cam, the Gearset agent, is a Salesforce AI agent that already understands how your org fits together. You tell Cam what needs changing, and it hands back a pull request that’s ready to deploy. This walkthrough shows how Cam takes work from your backlog to your pipeline.

You’ll learn how to:

  • Hand Cam a Jira ticket and let it check your repo and live org for context, including how field access is set up across your profiles
  • Answer Cam’s clarifying questions on access, data protection, and gaps the ticket missed, like adding a VAT country field
  • Review and approve Cam’s step-by-step plan before Cam starts building
  • Assign Apex and Flow errors from your production org to Cam, so long-ignored issues and technical debt finally get cleared
  • Check every change in the comparison view, then deploy to a sandbox or raise a pull request that’s already passed validation and your coding standards

Cam plugs into the Jira and Git provider you already use. Every change goes through the same approvals, tests, and security checks as your team’s work, so you build faster with AI without loosening how you ship.

Learn more

Transcript

Hi. I'm Maroof from Gearset, the Salesforce DevOps platform that helps teams get their changes into production safely.

Lots of teams now use AI to build changes faster, but this just moves the bottleneck. Every change still needs to be checked, tested, and released safely. That's why I'm excited to show you Cam, Gearset's AI agent. Think of Cam as an extra teammate that already understands how your org fits together. It builds to your team standards and runs every change through the same checks and approvals as the rest of your work, So you get time back for whatever needs you the most.

You tell Cam what needs changing, and it hands you back a pull request that's ready to deploy. Now let me show you what that looks like.

I can see the work that's been assigned to me and across my team. All of my tickets pulled in directly from our Jira board. This ticket's been sat here for a while. Sales reps are entering invalid VAT numbers, and it's causing problems in invoicing and reporting.

Finance wants each of these to be checked on entry and for any failures to be flagged to them, all without blocking the reps, of course.

Now this needs real care and attention, as we need the right access, a flow that finance can edit, and a placeholder until a later check is ready. But it doesn't require my expertise to build this, so I've handed it to Cam. Cam starts by checking our repo and the live org to get the context that it needs. In this case, where things are missing, it also looks for the closest fields that might be needed.

Right now, it's scanning across the related finance field, the accounts payable email, and it's gathering key context, like how access to it is set up across 23 profiles. With the context gathered and understood, Cam is ready to ask me some questions to help with the decisions.

It knows VAT numbers are sensitive business data, so how should access work for this field? Cam's already found our convention, so I'll tell it to match the accounts payable email field. The next one is one that I might have missed. Different countries format VAT numbers differently, So when we connect the real check later, it will need to know the country.

Should we add a VAT country field now? Yes. I'm gonna do that now. This is an example of a gap that I would have found out the hard way months from now.

And finally, does it need extra data protection beyond field level security? I'm happy that field level security is enough.

Cam asks because it builds on Salesforce best practice and knows how my org works, from the fields and the profiles we use to how they depend on each other. It doesn't assume or make things up. If a ticket leaves something out, it asks me. With those answers, Cam can start writing up a plan. Here you can see the nine steps it's proposed. The new fields on account, the placeholder Apex and its tests, a detailed flow for finance, our page layouts, and access across all 23 profiles to match the convention.

At this point, if there's anything I would like to add or change, I can just tell Cam, and it would update the plan.

This one, however, is good to go. So I'm gonna go ahead and approve and Cam will start building. Nothing will be deployed until I've seen what Cam has built. This is a great time to leave Cam to it and get on with something that needs me. Today, however, I'm gonna use that time to show you the part that I'm most excited about. Another way that I can delegate work to Cam.

Everything we've seen so far started with a ticket because someone asked for it. But you know those Apex and Flow error emails Salesforce sends? Well, they pile up fast and it's hard to tell which ones actually matter. So let me show you a really handy way that you can assign that work to Cam too.

Gearset helps you stay on top of your production org's health, including Apex and Flow errors, and surfaces them in suggested tasks. Nobody filed a ticket for these, but they're affecting the people who use our org every day. This one's been on our list for a while. We know about it. We know it needs sorting. We've just never had the time to get around to it. So I'm gonna go ahead and hand it to Cam.

Cam will follow the same process you've just seen. When ready, it will ask me if anything's unclear, write a plan for me to approve, then build it to our standards.

And we can finally get around to clearing errors and addressing some of our technical debt.

Here's everything else Cam's working on for me right now. As you can see, it's not only detailed tickets. I can hand it a business problem, a question about my org, or a half formed idea I haven't fully scoped yet, and Cam takes it from there and follows the exact same process by analyzing my org, asking questions it needs, and creating a plan for me to review and amend if needed. Now let's get back to my ticket. Cam's finished building, and I can see every step it took while I was away. I can see exactly what's changed using the same comparison view I'd use for any deployment, the two new fields on the account, access match to our finance fields, the placeholder Apex in preparation for the real check, and the flow that routes failures to finance.

It's all been checked against our coding standards, the same ones that apply to my team's work for bugs, performance, and security. Cam can't skip them, and it can't mark its own homework.

Now that I'm happy with the changes Cam has made, I can either deploy this to my sandbox to test or raise a pull request right into our pipeline.

A validation run will take place here, and if anything fails, Cam fixes it before it reaches me. So I'm never handed a pull request that won't deploy.

From here, it goes through the same approvals, tests, and security checks as anything our team writes, and we are ready to promote safely. So if your team wants to build faster with AI without loosening the way you ship, that's Cam. It knows your orgs, asks when something's unclear, and can start from what's breaking in production, not only what someone's asked for.

Cam plugs into the Jira and Git provider you already use and works through Gearset's platform. So every change follows the same rules and checks, whoever made it. And before it reaches you, it's ready to deploy. If there's a change your team hasn't had the time for, book a demo, bring it with you, and let's see what Cam does with it.