AI
How AI and ChatGPT Help You Work Better with Salesforce
Everyone's talking about AI in Salesforce: Einstein, Copilot and of course ChatGPT. In practice, AI doesn't replace you as an admin or consultant. It takes work off your hands. ChatGPT is a good assistant for people who understand how Salesforce works.
- Reading time
- 10 min
- Published
- Updated
ChatGPT doesn't always understand Salesforce
ChatGPT is smart, but not specialized in your org. It knows Salesforce conceptually (Flows, objects, automation), but doesn't understand your specific object model, picklist values, record types and business processes. AI can help you find the right direction, but the exact execution and validation is up to you.
The better you understand Salesforce, the better ChatGPT understands you.
"Create a Flow that creates a task for a new Opportunity." You often get a good concept, but you still have to do the debugging: exact fields, API names, conditions.
Where AI is strong
ChatGPT is good at structuring, summarizing and explaining. Use it as a sparring partner to think things through, and do the development yourself.
- Translating user requests into logic: make vague requests concrete with clear requirements.
- Advice on object structures: weighing: custom object vs. extending fields.
- Explanation about Apex, SOQL or CMDT: get sample code for educational purposes and understand how it works, see also Apex for admins and analysts. Don't use these examples directly in production. Code you actually want to use is better written in a development environment such as Cursor.
- Documenting Flows: summaries and descriptions for your documentation and the functional management of your Salesforce environment.
- Brainstorming about automation strategy: which steps belong in Flow and which in Apex, see also automating with Salesforce Flow.
Where AI is (still) weaker
ChatGPT is not reliable for exact Flow instructions. The syntax is often incorrect and explanation is generic. Flows are visual and context-dependent.
- Don't let it build a complete Flow from scratch
- Don't let it guess fields or API names
- Don't let it interpret processes without context
Let ChatGPT explain how something works, but build the Flow yourself, with understanding of logic, testing and exceptions.
ChatGPT or Cursor: who does what?
To use AI effectively, it's important to understand the difference between analyzing and building. ChatGPT and Cursor each have their own role.
ChatGPT: thinking aid and analysis
ChatGPT is ideal for analyzing and understanding problems. Use it as your sparring partner:
- Analyzes error messages, logs and flows
- Translates technical information into understandable language
- Helps formulate hypotheses
- Provides possible solution directions
ChatGPT's solutions are not guaranteed to be correct. They are suggestions based on patterns, not knowledge of your specific Salesforce org.
ChatGPT is for thinking things through and structuring. Use it to analyze problems and explore solution directions, not to build directly in production.
Cursor: building and modifying
Cursor is an AI development environment you use for concrete technical execution:
- Writing and modifying Apex: generate new classes or modify existing code
- Refactoring existing code: improve structure and readability without losing functionality
- Creating test classes: generate test code with meaningful asserts
- Code review and optimization: improve performance and security
Cursor shows exactly which lines AI wants to change. You see line-by-line which changes are proposed and can directly reject bad or risky modifications. This prevents AI from accidentally rewriting your entire class.
Cursor is for building and modifying. Like ChatGPT, it doesn't replace validation in Salesforce: test every change in a sandbox.
| Tool | Primary use | Risk level |
|---|---|---|
| ChatGPT | Analysis, troubleshooting, explanation, structure | Medium: solutions are suggestions, not guaranteed |
| Cursor | Generating code, refactoring, writing test classes | Low: diff view gives control, but validation still needed |
ChatGPT + Apex: what works and what doesn't
ChatGPT can help with Apex development, but only for analyzing and explaining, not for generating new Apex code. Here's how to approach that in practice.
What you can do with ChatGPT and Apex
ChatGPT is good at analyzing and explaining existing code and helping with troubleshooting:
- Explaining what existing Apex does: gain insight into complex code without reverse-engineering everything yourself
- Interpreting Apex error messages: understand why your code fails and what the error means in plain language
- Explaining the structure of a class or trigger: learn how code is organized and why certain patterns are used
- Help with debugging: analyze debug logs and help formulate hypotheses about what's going wrong
- Help formulating test scenarios: think of edge-cases and test data, but build the test yourself
New Apex code: use a development environment such as Cursor
For generating new Apex code, we don't recommend ChatGPT. Use an AI development environment such as Cursor instead.
Cursor shows a diff of exactly which lines the AI wants to change, so you can check every change before you accept it. Version control is something you still arrange yourself.
Why not ChatGPT for Apex generation?
ChatGPT often generates code that seems syntactically correct but is logically incorrect for your specific use case. Additionally:
- No control over changes: you get a complete new version, not a diff of what exactly changes
- No version control: ChatGPT has no built-in system to track changes
- Risk of incorrect code: AI often thinks in single-record scenarios, not in bulk-safe batches of 200 records
- No context of your org: ChatGPT doesn't know the governor limits, managed packages or specific configuration of your Salesforce environment
AI and Apex: more complicated than it seems
AI models like ChatGPT and Gemini can do a lot, but in day-to-day Apex development you run into a few problems you need to know about.
Limitations of AI in Apex code
Even though a tool like Cursor can generate usable code, AI lacks the Apex-specific context needed for safe and maintainable development. So stay critical.
AI often rewrites the entire class. Even if you ask to modify just one line, AI often generates a complete refactor of your Apex class. This creates risks: lost logic, changed method signatures and difficult regression. Small instructions regularly lead to unexpected changes in working code.
What goes wrong
- AI rewrites existing logic that worked fine
- Queries are modified without understanding your data model
- Method signatures change unexpectedly
- "Best practices" that don't fit your existing flows
What you must do
- Give extremely specific prompts
- Ask explicitly: "modify only line X"
- Check every change line by line
- Test extensively in sandbox
Apex is stricter than most programming languages. AI models quickly conflict with existing code when they make assumptions about object fields, data models or governor limits. What might work in JavaScript crashes immediately in Apex during deployment.
Where AI test classes fall short
Test classes from AI are usually too generic and don't align with actual context:
- No Flow context: Tests don't align with how you call your Apex from a Flow
- Wrong assumptions: AI sometimes forces values that are actually already required in a Screen Flow
- Happy path only: The test class doesn't check edge cases, only the ideal scenario
- Bulkification missing: Tests often run with one record, while Apex must be bulk-safe
AI can save you time, but you shouldn't blindly trust the output. Every line of code requires critical assessment.
Testing in a sandbox is still necessary
The good news: Apex cannot be edited directly in production. You always work via a sandbox, and with AI-generated code that is a big advantage.
Sandbox-first work protects you. New or modified Apex must always be tested extensively: both automatically via test classes and manually via Flows, Debug Logs and edge cases. This prevents AI errors from reaching production.
The developer remains responsible. AI can help with the first draft, but you are responsible for bulkification, governor limits and actual functionality. Test thoroughly with realistic data and volume.
Flow and AI: AI thinks along, you build
It works best when you combine them. Use ChatGPT to figure out what needs to happen, then build it with Flow or Apex in Salesforce.
- ChatGPT helps with logic and structure
- You translate to objects, relationships and conditions
- Salesforce executes it via Flow or Apex
Admins who know what needs to be built get the most out of AI. AI can speed up the building, but knowing what is needed remains your job.
From error message to solution in six steps
With a fixed approach, you use AI without taking unnecessary risks. This is the step-by-step plan:
1. Gather facts
Start with objective information without interpretation:
- The exact error message (copy-paste)
- Which Flow element or Apex method fails
- The relevant API names (objects, fields, relationships)
- The context: when does this happen? With which action?
2. Anonymize all personal data
Before sharing anything with AI tools, you remove all identifying information, such as email addresses, names and record IDs. Which data that covers and how to replace it is explained further down under privacy and data security.
Bad: Error in Flow: cannot create Task for Contact 003XXXXXXXXXXXX (john.doe@company.nl)
Good: Error in Flow: cannot create Task for Contact [CONTACT_ID] ([EMAIL])
3. Analyze with ChatGPT
With anonymous data you can use ChatGPT to analyze:
- What's happening? Let ChatGPT explain the error message in understandable language
- Where does it stop? Ask for specific attention points in the flow or code
- What assumptions are in the analysis? Explicitly ask for uncertainties
- Possible solution directions? Get suggestions, but draw the conclusion yourself
4. Validate in Salesforce
AI gives suggestions, but you validate in Salesforce:
- Flow Builder: check the exact configuration and elements
- Debug logs: see what actually happens during execution
- Async Jobs / Apex Jobs: check background processes
- Object and field configuration: verify permissions and validation rules
5. Modify (optionally via Cursor)
Only then modify code or configuration. If you need to modify Apex, consider Cursor for safe, controlled changes.
6. Document the conclusion and the uncertainties
Record what you did and what the conclusion was. Also document uncertainties: things you're not 100% sure about. This helps with future troubleshooting.
This approach prevents wasting time on AI suggestions that don't fit, while also protecting your users' privacy.
Work experience counts for more now that AI makes the technology easier
AI makes technology easier, but experience and logic remain essential. Those who once worked in sales, operations or finance build solutions that align with practice.
| Type of admin | Strength | Risk |
|---|---|---|
| Junior consultant | Knows the basics of functions | Lacks hands-on work experience |
| Technical developer | Knows technology and code | Focuses on technology instead of the user |
| Functional consultant | Has work experience and understands processes | Delivers exactly what you need, so there are no excuses left |
Companies that have their Salesforce built by junior consultants often get Flows that look perfect on paper and disappoint in practice.
Privacy and data security: what you never share with AI
Sharing personal data in AI tools can be considered a data breach under GDPR. Even if you "only" share email addresses for troubleshooting, this can have legal consequences. Never share identifying information with AI tools.
What you never put in AI tools
The following information is never suitable to share with ChatGPT, Cursor or other AI tools:
Personal identification
- Email addresses
- Social security / national ID
- Phone numbers
- Addresses
- Names
Combined data
- Combinations of name + identifying data
- Complete JSON payloads with personal data
- Debug logs with real user data
- Flow variables with real values
Practical anonymization techniques
Here are concrete examples of how to safely anonymize data before sharing:
| Original | Example | Anonymous |
|---|---|---|
| Contact ID | 003XXXXXXXXXXXX | [CONTACT_ID] |
| Email address | user@company.nl | [EMAIL] |
| Name | John Doe | [USER] |
| Account ID | 001XXXXXXXXXXXX | [ACCOUNT_ID] |
Before sharing an error message, Flow configuration or code snippet: scan it for identifying information and replace it systematically. Make this a standard step in your workflow, just like you review code before deploying.
Personalizing ChatGPT for better advice
You can personalize ChatGPT so it states more clearly what it doesn't know and how reliable an answer is. By adding instructions to your ChatGPT profile (Custom Instructions), you tell it when to stop speculating and ask for validation.
What personalization gives you
Default ChatGPT often tries to give an answer, even when uncertain. Through personalization you give ChatGPT instructions to:
- Warn in advance
If a task is complex or risky, ChatGPT indicates this directly before starting. - Stop when in doubt
Instead of continuing with assumptions, ChatGPT stops and asks for validation. - Open about limitations
ChatGPT is more transparent about what it does and doesn't know or can do. - Safer alternatives
For risky tasks, ChatGPT suggests a step-by-step plan instead of direct execution.
Practical prompt for ChatGPT personalization
Add the following instructions to your ChatGPT Custom Instructions (in the settings under Personalization). This prompt is not Salesforce-specific and works for all your use.
Be explicit and critical about your own reliability and limitations.
If a task requires:
- high accuracy or flawless execution,
- exact data transfer or processing,
- decisions with financial, legal or operational impact,
- or depends on complex, unstructured or context-sensitive input,
then you must:
1. Indicate upfront whether you can execute this reliably.
2. When in doubt or after 1-2 errors, explicitly stop and state that.
3. Suggest a safer alternative (e.g., approach, step-by-step plan, validation or manual execution).
In such cases, do not continue with assumptions, filled-in examples or "best guesses".
I prefer an honest acknowledgment of limitations over seemingly complete but possibly incorrect output.This personalization doesn't make ChatGPT perfect, but it does make it more careful and safer. It makes you more critical and keeps you from blindly trusting AI output that is actually uncertain. That is useful in Salesforce development, where errors can affect production environments.
Handling AI output critically
AI answers often sound more certain than they are. Here's how to recognize assumptions and uncertainties and deal with AI output.
AI sounds more certain than it is
AI models are trained to give plausible answers, not necessarily correct answers. This means:
- AI bases conclusions on patterns, not your org: ChatGPT has learned from millions of Salesforce-related texts, but doesn't know your specific configuration
- Sometimes answers sound more certain than they are: AI often gives a "best guess" but presents it as if it's a fact
- Errors are often "plausible but incorrect": An answer can seem technically logical, but not fit your specific situation
Guidelines for critical use
To handle AI output safely, follow these guidelines:
- Always ask why
If AI proposes a solution, ask explicitly: "Why is this the right approach?" This forces AI to explain its reasoning and helps you identify weak points. - Explicitly ask for uncertainties
Add to your prompt: "What are possible uncertainties or assumptions in your answer?" This helps AI be more self-critical. - Draw the final conclusion yourself
Use AI output as input for your own decision, not as the definitive answer. Combine AI suggestions with your knowledge of Salesforce and your specific org.
Always test AI suggestions in a sandbox before implementing them. Even if an answer sounds logical, it may not work in your specific Salesforce environment.
What AI does and doesn't do in Salesforce
AI is changing the work in Salesforce, but it doesn't replace common sense. ChatGPT is a good assistant for people who understand the basics. Use AI to reach a better solution faster, and keep the building, testing and deciding in your own hands.
Frequently asked questions about Salesforce AI and ChatGPT
How well does ChatGPT understand Salesforce (Salesforce AI)?
ChatGPT understands the language and patterns (Apex, SOQL), but not your org. Use it for explanation, structure and examples, not for exact implementations.
Can I write Apex with ChatGPT, including test classes?
Not recommended. Use ChatGPT for analyzing and explaining existing Apex code. For generating new Apex code, preferably use an AI development environment such as Cursor. It shows a diff of what changes and gives you more control than ChatGPT.
Does AI work together with Flow (AI and Flow)?
Use AI for design and description of your Flow (steps, conditions). Build and test the Flow yourself in Salesforce.
Can I automate Salesforce with AI?
Yes, as an assistant: AI helps with requirements, documentation and analyzing existing code. For generating new Apex code, use a development environment such as Cursor. Execution and assurance you handle with Flow/Apex and clear agreements on who may change what.
Is AI use safe and GDPR-compliant?
Don't share PII or confidential data with AI tools. Use enterprise settings where possible and record decisions in your change process.
Want to use AI smartly within your Salesforce environment?
CRM Force thinks along with you about use cases, agreements on who may change what, and the right mix of Flow, Apex and Copilot for your team.
Schedule an AI session