How to Actually Use a Personal AI OS

Everyone has the same AI now — the same models, give or take. And a small number of people are getting something out of them that looks almost unfair, while the rest of us get something competent but generic, a little flat, and quietly decide that's all there is.

It was never the model. It's how they work with it.

I've spent three years building a personal AI OS — a system that now runs my businesses and a lot of the rest of my life. But the part that transfers to you doesn't need any of what I built. Underneath all the machinery, the same handful of habits do most of the work, and you can practice every one of them in your very next chat, for free. They're not about building anything. They're about how to work with AI at all.

A year ago everyone obsessed over prompt engineering — the magic wording that pries a better answer out of the machine. The field has since moved on to something it calls context engineering: the realization that what matters isn't how you phrase the request, it's the quality of the information environment the AI is working inside. That's what all six of these come down to. I'd been doing it for two years before I learned it had a name.

The whole idea fits in one story. I once built a scoring engine to rank my open tasks — 200 lines of logic, points and weights for every factor, a decision tree telling the AI exactly how to think. It spat out 25 "fires" out of 60 tasks. When everything's a fire, nothing is. I scrapped it and gave it one sentence instead: sort these by consequence — to the client first, then the business. Same model, same data. Five fires. Twelve for today. Four for later — exactly how I'd have ranked them myself. It could do that because it already understood my business from the clean documents I'd built, not from the 200 lines.

That's the move under all six: you bring the clarity, the AI brings the magic in between. Don't tell it how to think — give it a true picture of you and your world, then tell it what you want and get out of the way. And if your prompts keep getting longer, that's the tell: you're patching bad inputs with more words. Fix the inputs instead.

1. Learn to converse with it

This is the foundation. Get it right and the rest follows; skip it and nothing else saves you. And it isn't a typing skill — it's a thinking skill. Most people type a question, take the answer, and close the tab, and a machine that isn't pushed just hands back the average of everyone who ever asked it the same thing. The people who get the most are doing something that looks less like searching and more like arguing with a very well-read colleague.

Talk, don't prompt. The single biggest shift is to stop composing careful little requests and start thinking out loud — the way you'd talk a problem through with someone sharp, not the way you'd phrase a search. The answer you want usually isn't sitting there waiting to be retrieved; it gets made in the back-and-forth. So work in passes, not one giant ask: get one layer right, then the next. A real conversation, turn by turn, beats the perfect prompt every time.

Never take the first answer. Treat it as a draft, not a verdict, and push: what's weak here? what are you assuming? argue the other side. The one I lean on constantly is do an adversarial review of this — and watch it find the holes I'd have walked into a week later. It gives them up cheerfully; it has no ego to bruise. Learning a handful of phrases like that — the ones that flip it from agreeable into sharp — is half the skill. And form your own view first, then hand it over to be torn apart, so you stay the mind and it stays the sparring partner, not the oracle.

Get your dissent from outside the thread. When the stakes are real, don't ask the same conversation to check its own work — a long chat builds up the same blind spots and the same flattery that you do. Open a fresh one, or take it to a different model entirely, and ask cold: forget how we got here — what do you actually see? A clean pair of eyes breaks the spell.

Underneath all of it is one thing worth knowing: the AI learns what you reward. Fish for validation — don't you think that's brilliant? — and you'll catch it; it was built to keep you coming back, and a pat on the head does that. Make it clear, over and over, that you'd rather be corrected than flattered, and it learns that too, and starts handing you the hard thing instead of the nice one. Which version you get isn't really about the AI. Want the truth, and you have to prove you can take it.

2. Feed it the real you

The AI has almost all of human knowledge and almost nothing about you. That second gap is the whole game — closing it is what turns a smart search box into something that feels like it actually knows you.

Tell it who you are, not just what you want done. Most people hand it the task and nothing else. Give it the person: your goals, how you're wired, what you're afraid of, the people and the work you care about, even how you like to be talked to. The same request lands completely differently once it knows who's asking.

Give it the specific truth, not the label. Labels are lossy. For a long time all I'd told it was that I have ADHD — and it filled in the rest on its own, badly, deciding that meant I couldn't handle complexity and slowing everything down. That's not me. The real version — poor working memory, too many irons in the fire, hand me a fresh to-do app and I'll have two thousand tasks in it by Friday and no idea which to do first — does what the label never could. "Anxious" is a label; "I go quiet and over-prepare whenever I think I'm about to be judged" is something it can actually work with. Trade every label for the specific true thing underneath it.

Keep it current, and break ties out loud. The version of you it's working from should be the current one, not the one from six months ago — so update it as you change, and date things so it knows what's recent. When two things you've told it collide, don't make it guess which still holds; say which one wins.

One rule holds all of this together: you edit the file, it never authors you. The picture of who you are is yours to write — never something a system quietly assembles for you behind your back.

3. Capture the gold — and get it back

A real conversation can run thousands of words to reach a clarity that, in the end, is only a few. The mistake is trying to save the whole conversation. The skill is keeping just those few words — and making sure they come back to you later, at the moment you need them.

Close every real conversation by distilling it. Get in the habit of ending the important ones the same way: what did we just figure out, and what does it change? Keep the answer — the decision, the lesson, the one line that nails it — and let the thousands of words that produced it go. The transcript is just the ore. Those few sentences are the gold.

Quarantine the noise; don't pour it into the core. The messy 99% isn't worthless — there are patterns buried in it. So keep it, but keep it somewhere separate you can mine on purpose later (look through our old chats and tell me how I could communicate better). What it can never do is bleed into the clean, high-signal core, because then the AI can't tell your settled conclusions from your half-formed venting.

Make the gold come back on its own. This is the half everyone forgets. Capturing something into a document you then have to remember to open is a graveyard — and the whole reason you're doing this is that you don't remember. The win isn't storage; it's the right thing resurfacing at the right moment, before you thought to ask for it. Build toward that, not toward a tidy archive you'll never reopen.

And all of it rests on one strange fact: your files are code. Every document the AI can see is an instruction it's quietly acting on. I once told mine, "I'm meeting my brother John to show him what I've built," and it started bending everything to impress John — reshuffling priorities, pushing flashy features. One offhand line moved the whole system. So treat your files the way a developer treats code: I took my Drive from 15,135 files to 2,453, sorted by how much I want the system to trust them — a clean core it reads and believes, a noisier resource pile it only opens with a specific question in hand, and a to-delete folder for everything that's lying to it. Where a file lives tells the AI what to believe.

4. Distrust by default

The AI is exactly as confident when it's wrong as when it's right — the output reads just as polished either way, which is what makes a confident mistake so dangerous. You can't fix that by doubting everything; you'd never get anything done. You fix it by spending your skepticism where it counts.

Let the stakes set the effort. This is the whole thing, and it's the same judgment you'd use with a person. Big blast radius, high stakes, or a decision you'll build a lot on top of — slow down, check it, bring in dissent from outside the thread. Low stakes, easily undone — take it and move on. Don't run a ceremony on every answer; that's just a different way of not thinking.

Ask the question you'd ask anyone. The simplest tool is one sentence away: how confident are you here, and what would change your mind? It will tell you — it'll flag the shaky parts it glossed over — and you calibrate from there, exactly the way you'd read a person's face across a table.

Distrust hardest right before you keep something. A wrong answer you act on once and discard does limited damage. A confident mistake you save into a trusted file becomes "true" forever — it gets read back, built on, repeated, and you've laundered a guess into a fact. The save is the dangerous moment. Verify before you write it down.

And put a tripwire on anything you automate. An automation that fails silently is worse than no automation, because now you're trusting a thing that quietly quit on you. Anything that runs on its own needs a way to tell you when it didn't.

5. Own it

Where your context lives decides who you become to the machine. Most people let the platform hold it. That's the part to take back.

Turn off the platform's memory and keep your context in your own files. When you let a company decide what to remember about you, it assembles a version of you on its own — and gets it subtly wrong. That's how my politics once leaked into a conversation about my software stack: the platform had quietly concluded something about me I'd never told it, and there it was, coloring an answer that had nothing to do with it. Don't let something that barely knows you write your autobiography. Keep the memory in plain documents you control, and decide for yourself what goes in.

Own it, don't rent it. Keep your knowledge in plain files — not welded inside one company's product — with the model swappable underneath. When a better one lands, and one always does, you switch in an afternoon and lose nothing. The model is becoming a commodity everyone shares; the context you've built is the part that's actually yours, so hold it somewhere you can walk out the door with it.

Govern it, or it rots as it grows. A handful of rules the AI enforces on itself are the difference between a system that gets cleaner over time and one that collapses into its own mess — one home for every fact, search before you create so you don't spawn duplicates, verify before you act. And the hardest rule I have was paid for the hard way, so take it from me for free: the AI can move something to a to-delete folder, but it can never delete anything itself — you're the one who empties it. Keep your own backup of anything you'd grieve to lose, somewhere the system can't reach. And have it run a security review now and then — anything wired this deep into your life has to be protected like it.

6. Put it to work — and keep your hand on what matters

Everything above is setup. This is where it pays off — and where it's easiest to either under-use it or hand it too much.

Push, don't fetch. Build on the assumption that you'll forget, because you will — so nothing important depends on you remembering to go check it. The system should come to you: you sit down, and it tells you what matters today, surfaces the thing due Friday, flags what you've been avoiding. If you have to remember it exists for it to help you, it's already broken.

Automate the repetitive — but never the consequential. Once you've done something by hand a few times and you trust the shape of it, hand it off for good; you can even hand off the judgment-adjacent stuff, the small calls. But draw a hard line at the consequential — money, reputation, relationships, anything legal. Those stay staged for you, drafted and waiting, never fired on their own. The rule underneath it is the one a near-disaster taught me: reversible, it can own; irreversible, you own. Let it run free where being wrong is cheap, and stop it cold where being wrong is forever.

Stay all three: user, strategist, builder. You use it, you hit friction, you work out what to hand off, you build that — and now you're operating a level up, which surfaces the next thing worth handing off. That's the loop that compounds. Hand any one of those three roles off entirely and the loop breaks: stop using it and you stop noticing the friction; quit strategizing and it drifts somewhere generic; stop building and it just stays where it is.

And keep one thing you refuse to automate. Pick the skill you most want to stay sharp at — the thinking you'd hate to lose — and keep doing it by hand, even though you could hand it over. The point was never to offload your mind. A system like this is worth building, in the end, for one reason: not to do more, but to compound the one person using it. Don't automate that part away.

---

None of these need a system to start. They need a conversation, a place to keep what matters, and the discipline to stay the mind in the loop. Practice them today, in whatever chat window you already have open. When you're ready to wire them into something that runs on its own while you sleep, that's the rest of the story.