How I Think About the AI Tools I Actually Trust
Auditability, reversibility, data ownership, transparency. What separates the AI tools I actually use from the ones I try and abandon.
The question I stopped asking is whether an AI tool is useful. Nearly all of them are useful, some of the time. The question I ask now is: what happens when it's wrong?
That shift happened after a small disaster. Not a catastrophic one — just a tool that had silently rewritten a preferences file I'd been building for months. The update was plausible. It was even, in a narrow sense, correct. But it reflected the AI's inference about what I wanted, not what I'd actually decided. The difference matters. Three months of small deliberate choices, overwritten by one confident but mistaken API call. I didn't notice for a week.
Since then I've been building a working heuristic for which AI tools I actually keep using versus the ones that get uninstalled within a month. It comes down to four things. None of them are about the quality of the AI output.
Can I see what it did?
The first test is auditability. When an AI tool takes an action — writes something, edits something, connects to a service — can I find a record of it afterward? Not a summary. A record: what specifically changed, what triggered the change, what the tool was authorized to touch.
This sounds like a developer concern. It isn't. I've found that the tools where I actually trust the AI are the ones where I occasionally glance at the log and find nothing surprising. It's the negative space that builds confidence. When I can't see what a tool did, I start to treat it as a black box. Eventually I stop using it for anything that matters.
The converse is also true. Tools that surface their actions — even a simple changelog or a diff view — feel more trustworthy over time, even when they make mistakes. Especially then, actually. A visible error is recoverable. A silent one compounds.
Can I undo it?
The second test is reversibility. Not in the trivial cmd-Z sense, but something deeper: if this tool wrote to my data, can I get back to where I was?
This rules out a surprising number of AI tools. Anything that syncs silently to a cloud database. Anything that builds a model of your preferences you can't inspect or reset. Anything where the AI's understanding of you is opaque and grows without your input. These are tools where "undo" is effectively unavailable — not because of technical limitation, but because the state was never legible enough to revert.
Good software is software you can exit without losing yourself. AI tools are where this principle sharpens, because the things AI tools touch tend to be the things that are hardest to reconstruct: notes from a specific meeting, a decision you wrote down for a reason you can no longer remember, the contact record you've been quietly annotating for two years.
Do I own the data?
Third: data ownership. This one is less about the AI specifically and more about the underlying product — but it shapes how much I trust the AI layer on top of it. If my data is stored in a format I can read without the app, the AI is less scary. If the data is locked into a proprietary format, or worse, opaque model weights that have "learned" me, then I'm not a user. I'm a training set.
The practical test: if this company was acquired tomorrow, could I export everything and continue? Not just export — restore, run, use. For most AI tools, the answer is quietly no. Most export features exist to check a compliance box, not to give you your data back.
Do I know what it's calling?
The fourth test is transparency of model calls. This is the most technical, but it comes down to: when the AI does something, do I know which model was invoked, with what context, and what it was authorized to touch?
Most tools fail this entirely. There's a chat interface, there's a response, and what happened in between is opaque. Some tools are better — they'll show you that a model was called with your notes as context, or that this particular action required access to your calendar. That specificity changes how I reason about errors. If something goes wrong, I can trace it. And if I can trace it, I can usually fix it.
There's a broader finding here. ManpowerGroup's 2026 Global Talent Barometer surveyed nearly 14,000 workers and found that while regular AI usage among workers rose 13% in 2025, confidence in the technology fell 18% over the same period. The gap is usually framed as a training problem. I suspect some of it is a legibility problem. Tools that tell you nothing about how they work don't accumulate trust, even when they work well.
This framework isn't universal. A grammar checker doesn't need an audit log. But anything that reads your notes, updates your contacts, or acts on your behalf in the background — that's where I think these tests apply.
The tools I keep using are almost without exception the ones where I could answer yes to at least three of these four. The tools I've abandoned tend to be the ones where the AI was impressive but the blast radius of a mistake was invisible. Impressive and opaque turns out to be less useful than merely competent and legible.
It's a strange thing to say about software, but: I trust the tools that seem to assume I'll check their work.
Asgeir Albretsen is the founder of Harbor.