From Coders to Crafters: The New Identity of Developers in the Agentic Enterprise

There’s a narrative that autonomous, self-supporting AI agents will eventually build themselves, putting developers out to pasture. 

Nothing could be further from the truth. 

Sure, companies can use one-shot, vibe-coded agents, but effective enterprise AI agents require more than letting a first-pass version run loose. Much like a specialty craft, the best production-grade enterprise agents undergo refinement — building, iterating, observing, testing, evaluating, and optimizing — to arrive at an effective product.

Instead of being replaced by AI, developers are becoming “AI artisans.

Jayesh Govindarajan, EVP Engineering, Salesforce AI

Instead of being replaced by AI, developers are becoming “AI artisans.” This shifts developers from writing code from scratch toward a specialized, human-led process of refining agents for specific business needs, ensuring they deliver precise and reliable results.

The first cut — craftsmanship in the Agentforce Studio

Before even making a first pass at creating an agent, teams need a broad blueprint of what one means and what it can look like. Such an expansive framework need not be tied to any particular task but delivers a ready contour for teams to build and refine. It includes defining the persona an agent takes, its customer interactions, and the skills and capabilities it possesses. It also includes understanding the permissions (access to data it’s granted) and accountability and checks it has to get the tasks done with accuracy.

Blueprint in hand, it’s time to take the first shot. Creating an agent involves drafting a vision for what the product will look like by specifying exactly what the agent will do and how. The artisan’s role at this stage is to ensure the agent has the right contextual knowledge and the right data. This information sets up the right data and actions for the agent to execute and instructions for how the agent should behave under prescribed circumstances. 

Agentforce Studio is the workshop where developer artisans can tailor out-of-the-box or build fully custom agents on Agentforce, Salesforce’s AI agent platform, tuning them with their domain-specific expertise. The more thorough the instructions, the deeper the context, the better the final product. Moreover, Agentforce Studio is open and extensible, with the ability to bring in data and actions across the enterprise ecosystem. 

Once the agent starts taking shape, it’s time for developers to ensure a working model. A note of caution: At this stage, agents aren’t ready for primetime and risk causing damage to established code and protocols if testing proceeds without any guardrails. To avoid adverse outcomes and limit damage from development mistakes if they do occur, Salesforce offers developer tools like Agentforce Testing Center, where teams can use AI to generate a series of relevant trial cases that can put the agent through its paces before it’s released.

The art of refinement — solving the ‘day two problem’

Building an agent is the first step in the lifecycle. Once in use, an agent will likely need to be refined and optimized to deliver the value it’s designed for. Some agents may work perfectly right off the bat in specific contexts while others may not. An agentic system is nondeterministic at its core, which means its output isn’t exactly the same every time. It needs to be observed, evaluated while at work, and when needed, retrained to ensure results meet established goals and guidelines.

Determining which contexts are troublesome and need refinement isn’t easy and is why Salesforce offers developers observability tools. Many look specifically for instances where agents aren’t working as they should. Specialized models in Agentforce serve as a judge, rating factors: Is the agent following directions? Is it pulling in the right tools, constructing the right inputs? Is it arriving at the outcomes it’s programmed for? If developers detect a problem, they march the agent back to the testing center drawing board to create more trial cases and analyze and fix the root cause of failure. 

Developer artisans can tune agents to do more and add new features, but they need environments in which such upgrades don’t lead to regressing on what’s already in production. Much like product design, crafting a successful agent is an iterative process, tinkering with functional parameters to deliver expected outcomes.

Much like product design, crafting a successful agent is an iterative process, tinkering with functional parameters to deliver expected outcomes.

Jayesh Govindarajan, EVP Engineering, Salesforce AI

From artisan to guildmaster — managing a fleet of agents

Once a few optimized and polished agents roll out of the workshop, teams now have a fleet to manage. Agents may make autonomous decisions, but they still need a human in the loop at times. Developers need to keep a constant eye on the ball and make agents’ operations visible, much like a single pane of glass that gathers field telemetry data for analysis. They can then detect rogue agents and intervene when the agent isn’t doing well and needs more human involvement in the loop.

With an expanding toolkit, developers can refine their craft across the entire agent lifecycle — from testing to observability and back to the builder experience with Agentforce Studio and Agentforce Vibes, a new vibe coding solution for companies. Unlike generic coding assistants, these solutions are designed for the enterprise, with security and governance built in through the Salesforce Platform and Trust Layer. The result: less time spent on compliance hurdles, and more time shaping smarter applications, integrations, and agents.

The first AI apprenticeship

With agents in the mix, developers need the right toolkit to become true artisans. This is where a partnership with forward-deployed engineers at Salesforce helps. These experts share their knowledge of the craft with customers, set up success criteria, and show how to set up metrics and use our observability tools. Just as code needs to make its way through the software development lifecycle, so too do agents. Fleets of agents making decisions and executing tasks autonomously can’t replace the value of a true developer craftsman. 

With the right tools, developer artisans can spearhead the human-led process of refinement, observation, and optimization that “chisels” agents into being — and into action. 

Go deeper:

• Learn about Agentforce Vibes, Salesforce’s vibe coding solution for the enterprise
• Download a five-step playbook to tackle ALM for AI agents and apps
• Find more insights on the developer’s changing role and tools to help