“Can we trust AI to touch our core financial systems or donor portals?”
Ask a careful executive director or VP and the answer is usually no. That’s a fair answer. Broken logic on a donation page costs you revenue, and it costs you donor trust.
I’ve been spending a lot of time on this in my Salesforce engineering work. Some changes to a system carry far more risk than others. Updating documentation or tweaking how code gets deployed is low risk. A change that touches what I call the money path, like payments, donor checkout, recurring gifts or receipts, has no room for error.
The safe way to use AI in those places is to sort the work by risk first, and then match how much the AI can do on its own to that risk.
Sort AI work into three risk tiers
In my Salesforce consulting work, we put every AI-assisted task into one of three tiers before anything reaches production:
- Tier 1: admin and documentation. Internal documentation, field descriptions, test templates and deployment settings. This is low risk, so the AI can do most of it with a light review.
- Tier 2: what donors and users see. Portal layouts, page updates and email templates. These need automated testing of the screens and a person signing off on the design.
- Tier 3: the money path. Payment gateways, recurring donation logic, receipts and syncs to your accounting system. Here the AI is tightly limited. It reads your live setup, tests edge cases in a sandbox and writes a step-by-step build plan. A person checks and approves every change before it ships.
The rule underneath is simple: the riskier the work, the less the AI does on its own. Let it take care of the tier 1 admin noise completely, so your experts can put their full attention on guarding the money path.
For technical readers: how this works in a Salesforce pipeline
Every change goes through a pull request, and each PR gets tagged by tier based on what it touches. A PR that only updates docs or tweaks a CI/CD pipeline moves quickly. A PR that touches payment flows, donor checkout, billing triggers or custom portal experiences gets the full treatment.
We’ve been building agent skills for scoping, build plans and automated code review, all grounded in live production metadata. The skills live in a shared GitHub repo the whole team uses. After each run, the agent checks its output against what actually happened in deployment. If it missed a metadata dependency or hit an edge case, it writes up a proposed change to its own skill definition in the repo. Each run makes the next one better for every engineer on the team.
How to set up risk tiers for your own systems
You don’t need a dev team to use this. The same thinking works for a small nonprofit with one CRM and a donation form.
- List the systems AI might touch. Think CRM, donation pages, donor portal, email tool and accounting software. Mark the ones that handle money or payment details.
- Put each kind of change in a tier. Anything that moves money, issues receipts or changes a recurring gift goes in tier 3. Pages and emails donors see go in tier 2. Internal notes and cleanup go in tier 1.
- Write down the rules for each tier. Say who reviews, what testing is needed and whether AI can make the change at all or only draft a plan.
- Test tier 3 work on a copy first. Use a sandbox with realistic edge cases, like a declined card, a refund or a gift split across two funds. A person signs off every time.
- Save every correction. When someone fixes a wrong assumption the AI made, add it to the shared instructions so the next run gets it right.
For leaders: keep what your team learns in the system
There’s usually a gap between the people who write code and the people who configure systems. Developers have version control and deployment pipelines. Admins and ops leads often keep business logic in spreadsheets, flow builders and scattered notes.
We build these self-improving skills for both groups. Picture an admin skill that checks which fields in your Salesforce org are actually used, flags orphaned custom fields and drafts a cleanup plan. The first time it runs, an admin corrects a small assumption about a custom object, and that correction goes into the shared skill. Two weeks later, a developer runs a scoping skill for a new integration. Because both skills share the same memory, the developer’s agent steers clear of those same orphaned fields.
That’s how institutional knowledge ends up in the system itself, instead of in someone’s head or a buried Slack thread.
Questions to ask before AI goes near your core systems:
- Which of our systems handle money or donor payment details?
- Who approves a change to those systems today?
- Where do our admins keep their notes on how the CRM is set up?
- When someone corrects the AI, where does that correction go?
Matching how much the AI does on its own to how risky the work is, and keeping every correction, are both built into Cosly, the AI staff team I’m building for small nonprofits.
