Picture three people landing on the same nonprofit page on the same afternoon.
One is a student writing a paper on red wolves. One just found an injured animal on the side of the road and has no idea who to call. One has been meaning to give for weeks and has their card out.
All three get the same big Donate button.
That is how most nonprofit sites work. One page, one ask, every visitor. When teams try to fix it, “personalization” usually turns into tracking and guessing. Segments, retargeting, a model quietly deciding who looks like a donor. It works well enough that people tolerate it, and it is also a little bit creepy.
I wanted to see if a page could do better without guessing about people. So I built a prototype called Adaptive Giving. It is a working site for a fictional wildlife nonprofit, Longleaf Wildlife Trust, and it changes what it shows based on what a visitor is trying to do. Someone researching gets a reading path. Someone who cannot give money gets a free way to help. Someone ready to give gets the gift form. Someone who found an injured animal gets the wildlife care line and nothing else.
The idea came from a fork I made of ShapeShift, where a plain text box turns into the right interface instead of answering like a chatbot. I kept thinking about what that would look like on a donation page.
That thing a visitor is trying to get done has a name. It is called an intent.
I have had my fair share of intents. I used to build enterprise chatbots for a court system using Dialogflow, and every conversation started with the same question. What does this person actually want? To pay a fine, to find a hearing date, or to get help with something else entirely. In Dialogflow you trained each intent with example phrases and hoped people talked the way you expected.
Same question here, minus the chatbot. A nonprofit site is full of intents. Learn about the work. Give. Volunteer. Find an event. Get help. Most sites treat them all the same.
What a visitor sees
There is a box on the page that asks how you would like to make a difference. You type a sentence and the page becomes the right experience. Nothing answers you back. The page just changes.
Type “I want to donate $100 to protect wolves” and you get the gift form with $100 already filled in. Ordinary code parses the amount, not the model. Type “I want to help but I can’t donate” and you get a free action instead.
Type “I want to sign up to volunteer and donate $10” and you get two options as tabs, with the $10 already sitting in the gift form. Ask “When is the gala?” and you get a date card with buy tickets, tables and sponsorship, and add to calendar. The dates, prices, and the calendar file all come from code.
Every one of those is a different intent, and every one of them used to get the same Donate button.
What Jev does here
So who works out the intent? That is Jev, a model from TypeSafe AI. It is a classification model, not an LLM. It is not built to chat, and you do not prompt it for paragraphs.
In this project it has one job. It scores intent.
When a visitor types a sentence into the box, I hand that sentence to Jev along with a short list of questions. What are they after? How ready are they to give? Might they need help? Jev answers each question with a number between 0 and 1, plus a confidence. The higher the number, the more strongly their words point that way. There is no training on example phrases. The questions are written in plain English.
Take “I want to help but I can’t donate.” Jev scores that high on wanting to help and picks up that they cannot give money. That combination is what sends them to a free action instead of a gift form.
It works the same way on behavior. Instead of a sentence, Jev can be handed a small snapshot of what someone has done on the page so far and score that.
The questions come in three flavors: pick one option from a list, place something on a scale, or estimate the chance that a statement is true. One call can carry a bunch of them, and the answers came back in roughly 150 to 400 milliseconds. That is fast enough that nobody waits on it.
That shape matters more than it sounds. Software cannot do much with a nice paragraph. It can do a lot with “this person is probably trying to donate, and the model is 95 percent sure about that.”
Jev decides, code renders
This is the rule the whole project is built on, and I think it is the most transferable part.
Jev handles the fuzzy judgment. What a visitor is probably after. How ready they look to give, and how sure it is about that. Whether they might need help. Which paths a typed sentence is asking for.
Code handles everything with consequences. The thresholds for leaving the page alone, nudging gently, or changing it strongly. Whether the donation form expands. Every date, price, seat count, total, and calendar file.
Jev is never asked to pull out a dollar amount, do math, write copy, or build any HTML. It returns a key, and my code renders whatever is behind that key. Every word a visitor sees is an approved variant the nonprofit wrote ahead of time. A draft variant can be stored but it can never render, and there is a test that proves it.
That split is what makes this safe enough to put in front of real people. The model gets the part it is good at. It never gets to decide anything you would have to apologize for.
Here is the whole path, from a visitor’s words to the page they end up seeing.
The ethics became design constraints
A few rules shaped everything else.
Help outranks fundraising. If a visitor might be asking for help, every ask disappears. I set that bar deliberately low, lower than the bar for showing a donation prompt. A false alarm costs a moment of screen space. A miss costs much more.
Being ready to give and the model being sure about it are two different things. A visitor can look very ready, but if the model is not confident, the page changes nothing. When it is unsure, the page stays as it is.
The model only sees a small, validated snapshot of what someone typed or did during their visit. There are no sensitive attributes and no attempt to work out who a visitor is. Confidence is never shown to visitors. The nonprofit approves every word, and the whole adaptive layer can be turned off.
What broke when it met the real model
Scoring intent sounds simple until you watch it work on real sentences.
I built the first version against a local stand-in that returns the same kind of answers as Jev. It hid nearly everything below. The first time I ran against the hosted model, three things went wrong, and they all taught me the same lesson. A score is only as good as the question you asked.
A learner got shown injury guidance. The sentence was “I want to learn why red wolves are endangered.” One of my questions asked whether the visitor might need help, and Jev scored this sentence 0.44. My rule says anything above 0.40 pulls every ask off the page and shows the wildlife care line. So someone who wanted to read about wolves got told what to do about an injured animal.
I did not raise the threshold. That would have made real help requests easier to miss. I rewrote the question instead, spelling out what counts as asking for assistance and what does not. The learner dropped to 0.17. Actual help requests stayed between 0.59 and 0.92.
The threshold was fine. The question was fuzzy.
One sentence, two intents. Take “I want to sign up to volunteer and donate $10.” At first I asked a single question, what is this person after, and let Jev pick a winner. It said donate at 0.81 and volunteer at 0.11. When a question forces a winner, the second request nearly disappears.
So for typed sentences I now ask a separate yes or no question for each path. Do they want to donate? Do they want to volunteer? Asked that way, sentences like this one scored between 0.88 and 0.98 on both, and the page shows two options.
Then the new questions got too eager. “When is the gala?” scored 0.79 on wanting to learn, and “sponsor the gala” scored 0.83 on wanting to donate. A simple question about an event looked like it was asking for two things. I tightened the wording of the questions and added one small rule in code. Still no threshold changes.
Here is what I took from all of it. When you are scoring intent, the wording of each question is part of the system’s behavior. Change a sentence and you change what the page does. That means those questions deserve tests, the same as any other code.
Try it yourself
The demo is live at adaptive-giving.samtate.ai. Type a few sentences into the box and see what the page does. Try to trip it up.
My plan is to keep using this project to show how adaptive UI can grow with modern tech. This is the first version, and it is built on purpose to be extended.
Who else could use this
Nonprofits are the obvious fit, and they are the ones I know best. The pattern is broader than donations though.
A public benefits site has the same problem. People arrive trying to apply, check a status, or figure out if they qualify, and most of them see one generic page. A university, a health system, or a city has dozens of audiences hitting the same front door. Anywhere a site has many kinds of visitors and a limited number of good next steps, something that reads intent can pick the step.
If you lead a nonprofit, a few questions are worth sitting with. What are the handful of things people come to your site to do? Which of them does a Donate button fail? And what should your page do when it is not sure what someone wants?
The part I would keep no matter what is the split. A model reads intent. Approved content and deterministic code decide what happens next.
Where this goes next
Jev is not an LLM. If you take one thing from this post, I would like it to be that.
An LLM generates the most likely next words. Ask it the same question twice and you can get two different answers, and it will sound sure of itself both times. That is fine for a draft or a brainstorm. It is a lot less fine when the output decides what someone sees on your donation page, or whether a person who needs help sees a donation ask.
Jev is a classification model. It does not write anything. It picks from answers you defined ahead of time and tells you how sure it is. That takes a big chunk of the unpredictability off the table. The worst case is a wrong score on a question you wrote, not a confident sentence you never approved. You can test that, tune the wording, and decide exactly how sure it has to be before the page acts.
I do not think this is LLMs versus classifiers, though. I think it is both, doing different jobs.
Picture an LLM at the front door. It reads a messy, half formed request, the kind real people type, and works out what someone is actually asking for. Then Jev scores that understanding against the intents the nonprofit has approved, and plain code picks the experience. The LLM brings understanding. Jev brings control. Each one covers for the other’s weakness.
I have not built that layer yet. It is where I think adaptive UI is headed, and it is what I want to explore next.
What this does not prove
Longleaf Wildlife Trust is fictional, and donations on the demo are simulated. Nothing is charged.
I am not claiming adaptive giving raises donations. I do not know that yet, and a real nonprofit would have to test it with real traffic and real care.
What I do know is that the pieces work. A page can read what someone is trying to do, change to fit, stay quiet when it is unsure, and put help ahead of fundraising every time.