kikminev

Agentforce for Developers: Building the Next Generation of AI Agents for Small Business

From Assistive to Agentic: Salesforce’s Agentforce for Small Business

In the world of Salesforce, the leap from “assistive AI” to “agentic AI” is no longer just a trend—it’s the new standard. With the recent announcement of Agentforce for Small Business, Salesforce is bringing its most advanced autonomous AI capabilities into accessible suites for smaller organizations.

For developers, this marks a shift in how we build on the platform. We are moving away from building simple chatbots and toward architecting autonomous agents that can reason, take action, and handle complex business workflows independently.

From Copilot to Agentforce: What’s the Difference?

Earlier iterations of Salesforce AI, like Einstein Copilot, were largely reactive—waiting for a user to ask a question and providing a response. Agentforce, by contrast, is proactive.

An agent doesn’t just answer, “What is the status of this case?” It can be configured to:

Detect a new case

Analyze the sentiment

Search the knowledge base

Draft a response

Resolve the case by triggering a Flow or an Apex action

All of this happens without a human clicking a single button.

The Developer’s Toolkit: How to Build an Agent

Building an Agentforce agent for a small business isn’t just about prompt engineering; it’s about defining the logic and boundaries of its autonomy. Here are the core components developers need to master:

Topics and Instructions
Define the “Topic,” which is the scope of the agent’s work, and provide natural language instructions. This tells the agent how to behave, what tone to use, and what its primary goals are.

Actions (The “Hands” of the Agent)
This is where the real power lies. Developers can expose existing Salesforce Flows, Apex classes, or Prompt Templates as actions. If an agent needs to check inventory or update a lead’s status, it uses the action you’ve built to interact with the database.

Guardrails
For small businesses, trust is everything. Developers must configure guardrails to ensure the AI doesn’t hallucinate or access data it shouldn’t. This is managed through the Einstein Trust Layer, but fine-tuning the instructions is critical for reliable performance.

Why This Matters for Small Businesses

Traditionally, complex automation was the domain of large enterprises with massive development teams. Agentforce levels the playing field.

A small shop with just a few employees can now have:

A Service Agent that handles 24/7 customer support

A Sales Agent that qualifies leads overnight

By integrating these tools directly into Salesforce Starter and Pro Suites, the barrier to entry has essentially vanished.

The Future is Agentic

As developers, our role is evolving. We are becoming “Agent Orchestrators.” Instead of writing every line of a step-by-step process, we are building the capabilities—the Flows, the Apex, the Data structures—and then teaching an agent how to use those capabilities to solve problems.

If you haven’t started experimenting with Agentforce in a sandbox or developer org yet, now is the time. The agentic era is here, and it’s transforming small business operations one action at a time.

JetBrains AI for Salesforce – the basic way to start using AI for Salesforce

If you use IntelliJ with Illuminated Cloud, you’re already doing the heavy lifting. Adding the AI Assistant just makes the boring parts of Salesforce dev move faster. It’s basically a specialized search engine that lives in your sidebar.

What it actually does for Apex

The “I hate writing tests” button: Highlight a method, right-click, and tell it to write the test class. It’s not perfect, but it handles the System.runAs, the @TestSetup, and the basic System.assertEquals lines so you don’t have to.
The SOQL Shortcut: Instead of clicking through Schema Builder to find a field name, you can just type // Get all contacts where the account is active and let the AI fill in the query.
Fixing “Variable does not exist”: If you have a weird null pointer or a syntax error, the AI can usually spot the missing bracket or the typo in a second.

Using it for Lightning (LWC)

HTML/CSS help: If you can’t remember the exact SLDS (Salesforce Lightning Design System) class for a specific button layout, just ask the AI to “make this div look like a standard Salesforce card.”
Boilerplate JS: It’s great at writing the @wire service calls and handling the basic then/catch logic for calling Apex from your JavaScript.

Simple Setup Tips

If you’re going to use it, do these three things to keep it from being annoying:

Use the “Explain” feature on old code: If you inherited a giant, undocumented Trigger from five years ago, highlight it and click Explain Code. It gives you a bulleted list of what the code is doing. It’s a lifesaver for onboarding.
Create a .aiignore file: This is important. Put your .sfdx folder and any local data files in here. It tells the AI, “Don’t look at these files.” It keeps your local config private.
Prompt for “Bulkification”: If you write a quick loop, you can ask the AI: “Is this bulkified?” It will point out if you accidentally put a SOQL query inside a for loop (the classic Salesforce mistake).

The Bottom Line

It’s a tool for your belt. It won’t build your org for you, but it will save you from typing the same testMethod headers a thousand times.

Understanding Binary Search

Binary search is a super efficient way to find an item in a sorted list. Instead of checking every single item one by one, it splits the list in half repeatedly until it finds what you are looking for.

Think of it like looking up a word in a dictionary: you open it to the middle, decide if your word is earlier or later, and then repeat the process with the correct half.

How it works:

1. Find the middle element of the array.

2. If the middle element matches your target, you’re done!

3. If the target is smaller, repeat the process on the left half.

4. If the target is larger, repeat the process on the right half.

function binarySearch(array $array, int $target): ?int {
    $low = 0;
    $high = count($array) - 1;

    while ($low <= $high) {
        // Use the middle index
        $mid = $low + intdiv($high - $low, 2);

        if ($array[$mid] === $target) {
            return $mid;
        }

        if ($array[$mid] < $target) {
            $low = $mid + 1;
        } else {
            $high = $mid - 1;
        }
    }

    return null;
}

// Example usage:
$data = [10, 22, 35, 47, 50, 68, 75];
$result = binarySearch($data, 47);

echo ($result !== null) ? "Found at index: $result" : "Value not found.";

Linear Search in PHP

Linear search is one of the easiest search algorithms to understand. It does exactly what the name suggests: it looks at items one by one until it finds what it’s looking for or reaches the end of the list.

There’s no trick to it. If you have an array, linear search starts at the first element, compares it with the value you want, and keeps going until it either finds a match or runs out of elements.

How it works:

1. Start from the first item in the array

2. Compare it with the target value

3. If it matches, stop

4. If not, move to the next item

5. Repeat until the array ends

When should you use it?

Linear search is fine when:

The array is small

The data is not sorted

You want something quick and easy to write

It’s not the fastest option for large datasets, since it may have to check every item. But for simple tasks, it gets the job done without extra complexity.

A bit of history

Linear search is basically as old as computing itself. Early computers didn’t have fancy data structures or fast memory access, so checking data one piece at a time was the normal approach. Even before computers, people used the same idea—think of flipping through a phone book page by page or checking names on a handwritten list.

Because of that, linear search is often the first algorithm taught in computer science. It’s not impressive or clever, but it mirrors how humans naturally search, which is why it has stuck around for so long.

Simple, clear, and still useful today.

Notes on Algorithms (with a bit of history along the way)

I’m starting a short series of posts about algorithms and basic computer science. The goal is to explain ideas clearly, without unnecessary jargon, and to understand them better by writing them out. Mostly this is about slowing down, breaking things apart, and seeing how they actually work.

Marketing Cloud Next Already Looks Like a Big Step Forward

I’ve spent some time in the old Marketing Cloud to say this: it works, but it’s not exactly friendly. It can be slow, cluttered, and harder to navigate than it needs to be — especially if you’re just trying to get a campaign out the door.

That’s why Marketing Cloud Next already feels so promising, even without having used it in practice. The new interface looks cleaner, more modern, and far more intuitive. It seems like Salesforce finally focused on how marketers actually work, not just on adding more features.

Everything about Next suggests less friction — fewer clicks, clearer workflows, and a platform that doesn’t fight you at every step. If the experience lives up to how it looks, this could be a huge improvement over the old Marketing Cloud and a much nicer place to spend your day.

Here is some more information that I stumbled upon on Salesforce Ben:

https://www.salesforceben.com/6-reasons-why-marketing-cloud-next-may-really-be-the-next-big-thing-in-salesforce/

Process Automation and Its Impact on Small and Medium Businesses

Understanding Process Automation

Process automation refers to the use of technology to perform recurring tasks or processes in a business without manual intervention. This can involve the use of software, artificial intelligence (AI), robotics, or other digital tools to streamline operations, reduce human error, and increase efficiency.

At its core, process automation eliminates repetitive and time-consuming tasks, allowing employees to focus on more strategic and creative activities. From small businesses to large enterprises, automation can be applied in various departments, including finance, human resources, customer service, and supply chain management.

Continue reading “Process Automation and Its Impact on Small and Medium Businesses”

Making the Case for Salesforce: From Skeptic to Supporter

Why Salesforce is Worth the Investment: Powerful Automation for Every User

At first, I was skeptical about Salesforce, mainly because of its high price tag. I wondered if it was truly worth the investment, especially when compared to building custom software solutions. Being a PHP developer capable of addressing business needs with custom solutions, I was particularly doubtful. I assumed that custom development or other affordable but basic CRMs would always be the better option. But then, I saw real-life examples of businesses cleverly using Salesforce to automate processes while focusing on their core operations—without the constant need to coordinate the development and delivery of custom software.

Over time, I realized that custom-made software comes with its own challenges—it’s expensive, takes longer to implement, and often requires multiple costly iterations to get right. Additionally, as business requirements evolve, companies relying on custom solutions remain dependent on programmers or software vendors for even the smallest updates.

Continue reading “Making the Case for Salesforce: From Skeptic to Supporter”

Evaluating Dynamic Formulas in Apex – A Game Changer for Salesforce Developers

With the Spring ’25 release, Salesforce has introduced the ability to evaluate dynamic formulas directly in Apex using the new FormulaEval namespace. This enhancement provides developers with a flexible and efficient way to work with formulas programmatically—without having to rely on hardcoded formula fields or complex workarounds.

Previously, if developers needed to evaluate formulas dynamically, they often had to rely on custom logic, additional fields, or even external processing. Now, with this new feature, Salesforce allows us to create and execute formulas on the fly, significantly improving the efficiency and flexibility of Apex code.

Continue reading “Evaluating Dynamic Formulas in Apex – A Game Changer for Salesforce Developers”

“problem: No package.xml found” when deploying to Salesforce via Workbench

Recently I had to delete apex classes and since doing so using Workbench is one of the easiest way I went for it. With Workbench you can deploy a package.zip file that contains the files you want to delete in a specially formatted destructiveChanges.xml and a package.xml. When using mac I stumbled upon a problem:

problem: No package.xml found

Continue reading ““problem: No package.xml found” when deploying to Salesforce via Workbench”

Kik Minev

Hey there, I'm Kik Minev - web developer playing with clouds, LAMP, Symfony, JavaScript, Salesforce Apex. Currently working as a Salesforce developer as part of the Taylor & Hart team.

My experience

Taylor & Hart - Salesforce and Symfony developer

Oxxy - CTO

Webfactory - Web Developer

Webfactory / Protect Your Bubble - Team Lead

Digitalus - Web Developer

SiteGround

What I work with?

PHP

JavaScript

Symfony

AWS

Git

Docker

Salesforce Apex

Ligning Components

PhpStorm