Most digital transformations fail because they’re fragile. You build a workflow, a small detail changes, the system breaks, and someone spends two hours fixing it. I call that the fragility tax, and it adds up fast.
Most software stays the way it was the day you installed it. From then on it starts to age. Every time it hits a situation the developers didn’t plan for, it breaks, and you pay someone to step in and fix it.
In the platform I’m building, I’m taking a different path. I’ve become a bit obsessed with agent skills that heal themselves.
How a self-healing system works
A 2026 organization needs automation it can see into. The technical word for that is observability, which means you can watch what your agents are doing and see where they get stuck.
In my build, a monitoring layer watches the agents while they work. When a person has to step in, because an agent hit a wall or said it couldn’t do something, that fix gets treated as a lesson. The system then runs it through a loop:
- Log. The agent records the failure instead of quietly stopping.
- Review. An audit agent reads the log and turns the person’s correction into an item on a technical to-do list.
- Fix. A developer agent picks up that item and updates the skill, so that specific failure doesn’t happen again.
This also answers a question I get a lot. If we’re supposed to think of AI agents as hires, who manages them? In this setup, another agent does.
Each failure ends up improving the system. For a small team, that means your capacity keeps growing over time without adding management overhead.
Documentation as part of every task
The same idea works for memory. Whether I’m using Claude Code for development or an agent for donor research, I give it one instruction it can’t skip: every task ends with an update to your own documentation.
Nonprofits lose a lot of what they know every time a staff member leaves, because that knowledge lives in people’s heads. With agents, the lessons from each task go straight into the organization’s shared memory. Here’s what that looks like in practice:
- An agent fails to categorize a complex grant.
- I give it the missing context.
- It updates its memory and documentation right away, so the next grant like that goes through.
Documentation then happens as part of the work, instead of being a chore saved for Friday afternoon. Picture your team’s memory growing every time someone solves a problem.
How to use the pattern with the AI you have now
You can start using this pattern today. Most people treat ChatGPT or Claude like a vending machine. You put in a coin and get a snack, and if it’s the wrong snack, you complain and try again.
Treat your AI more like a student, and set up a simple version of the loop yourself:
- Ask it to log the lesson. Every time you have to fix something, ask the AI to write down what it learned. Try a prompt like this one: “You missed the tone on this donor appeal. I had to change the ending by hand to be more community-focused. Please log this correction in your memory or documentation for this project so you don’t make this mistake in our next draft.”
- Keep the log somewhere you can read it. In most chat tools that means a project’s instructions or a saved document the AI reads each time. Check that the correction actually landed there.
- Keep a tally of when you step in. Each time you or a colleague has to redo part of an AI task, add a line to a shared note with the task and what went wrong. That’s your own small monitoring layer.
- Watch for repeats. If you have to correct the AI twice for the same mistake, the lesson didn’t stick. Go back and check where it was saved.
- Review the log once a month. Read through the lessons, merge the duplicates and delete anything that’s out of date. Move the ones that apply to everyone into your team’s shared instructions.
When you make the AI write down what it learned from your correction, you’re running a manual version of the loop I described above. The goal is to stop repeating yourself.
For leaders: track where your AI needs help
Your organization’s AI should be more capable on Friday than it was on Monday, without anyone on your team writing a line of code. That only happens if the fixes go somewhere.
AI tools are starting to learn from their own mistakes, which means a single fix can become a lasting improvement. You still need to know how often your people are stepping in, and what happens to those fixes. A few questions to ask:
- How often do staff have to step in and correct AI output?
- When they do, where does the correction go?
- Who reviews the corrections and decides which ones become standing rules?
- Is our AI doing better this month than last month, and how would we know?
A good first step is to ask each person who uses AI to log one correction this week, then look at where those corrections ended up.
