How I (Currently) AI

I've learned a lot from Claire Vo's How I AI, especially from seeing how different people actually use AI tools in practice. It got me thinking about my own setup and habits, so I figured it was worth writing down where I've landed right now.

Part of this is to share what has been useful for me in case it helps you too. Part of it is for future me. These tools are changing so quickly that in a few months, some of this may feel outdated or incomplete, and I like having a snapshot of how I'm approaching AI right now.

Treat AI like a smart new hire

The mental model that works best for me is treating AI like a smart new hire. They know a lot, probably more than you across a wider range of topics, but they don't know you. They don't know your workflows, your codebase, your preferences, or the context behind why things are the way they are. You have to onboard them.

Once you see it this way, you stop expecting it to read your mind and start thinking about what context it actually needs. Before any task, I ask myself: does the AI have enough context to give me what I need? If not, I collect it, dump it in, and organize from there. But onboarding doesn't mean dumping everything at once. Token windows are finite (for now), and more context doesn't mean better output — the same way you wouldn't firehose a new hire on day one.

Everyone becomes a manager to some extent. You're delegating, reviewing, redirecting, and juggling many things at once, the same things you'd do with a capable person who just joined your team. You'd review their plan before letting them build. You'd re-plan with them when things go sideways instead of pushing forward. You'd give them feedback when they do things that aren't quite right, and teach them how to improve next time.

Honestly, working with AI is mostly just communication now. It's gotten good enough that you can usually just tell it what you want in plain language, instead of hunting for the exact prompt formula like people did early on.

What AI is good at

Once you have that mental model, it gets easier to see where AI is actually useful. Think about what it's good at and don't push against it. That also means thinking about what tools it has access to. If the surface isn't strongly compatible with AI, try to find an alternative that is if available.

For example, if you need slides, consider an HTML-based slide tool like Reveal.js instead of PowerPoint or Google Slides. It's just easier for AI to manipulate HTML than to have the right integrations into those apps. The same applies to why Markdown is such a powerful format for working with AI: it's just a file (shoutout Obsidian). The more your tools are native and look like text and files, the more easily AI can read and manipulate them.

One of the biggest shifts has been how good AI has gotten at tool use, especially since the Opus 4.5 launch in late November 2025. It changes what you think is possible. Search, file operations, CLI commands, browsing: it can just find things for you. And if you want more deterministic outputs, you can ask AI to generate scripts or create its own tools to help with that, rather than relying solely on token prediction.

AI is also relentless. You can ask it to improve itself, review its own output, do another pass, check for mistakes, rewrite in a different tone. You can really push on it. Challenge it: make it justify its changes, act as its own reviewer, prove that what it did actually works. Most people treat it as a one-shot interaction when it's really a conversation.

Lastly, AI is almost always a good first step. The cost of throwing away what it produces is so low that there's no excuse not to just try. This applies to brownfield projects just as much as greenfield experiments. As long as you have good version control, you can backtrack easily. And because AI did most of the work, you don't feel bad about tossing it. You get a lot more agency to just try things.

Workflow things that help

1/ Agent skills

Once you know where AI tends to help, the next step is making that help repeatable. When you find yourself giving the same instructions over and over, that's a signal to write it down somewhere the model can find it. Say you manage tasks in a specific project with its own vernacular, labels, and workflows. A model will never know any of that unless it's told. An Agent Skills SKILL.MD file that captures that workflow means you can invoke it and skip the re-explaining.

Skills aren't the only way to do this. Some tools support memory files (like MEMORY.md in OpenClaw), profile files, or project-level instruction files like AGENTS.md. I like to capture workflows in skills and persistent things (preferences, project context, personal details) in memory or a PROFILE.md. Find what works for you, but the point is the same: if you keep repeating yourself, put it somewhere the model can read so it can learn for next time. You can also ask AI to improve on skills over time (e.g. ask it to read through the conversation history, find where it didn't quite align to the skill, and have it edit the skill so it doesn't happen again next time).

Some skills I've found useful: ask-questions-if-underspecified (courtesy of Tibo), which teaches the AI to clarify before it acts instead of guessing. Best-practices skills like git-best-practices, writing-best-practices, or react-best-practices (courtesy of Vercel) that encode how you want things done, though these may matter less over time as models get better at the basics unless they're particular to how you work.

2/ CLI tools

I still prefer CLI tools over some of the newer apps like Codex, Claude Code, or integrated IDEs like Cursor or Kiro IDE. The CLI gives me a bit more flexibility, especially when combined with native tools. There are a lot of benefits to learning terminal tools like yazi, tmux, and lazygit because 1/ these tools are super customizable and AI is really good at editing config files on your behalf to get the tool to work just the way you want and 2/ the terminal works in so many places, such as on cloud desktops where you don't always have a graphical user interface to play with; it gives you real flexibility.

3/ Parallel agents

I open multiple agents at once and treat them like different Slack threads. One might be working on a code change, another helping me draft a doc, another looking something up. They don't need to share context, and I don't need to wait for one to finish before starting another.

4/ Voice inputs

Voice input is still super underrated in my mind. I'll ramble for a few minutes providing context, and it sorts through it and pulls out what matters. You don't need to have your thoughts organized before you start talking. You also talk faster than you can type, which is a great way to provide even more context. Tools like Monologue.to, VoiceInk, and handy.computer are great for this, and Codex and Claude both have voice natively now too. (Warning: Be careful though because sometimes you can talk faster than you think.)

What's still hard

That said, some of the tradeoffs of using AI are real. Brain drain is real. When you offload too much thinking to AI, you can feel it. You have to be careful of atrophy of thought. It's not just that you forget things, it's that you stop exercising the muscle of working through problems yourself.

It's also mentally taxing. Maybe this is how managers feel, but to juggle and think deeply about so many topics just so you can keep up with all your different agents is very difficult still. I haven't quite figured out a way to adapt to this quite yet.

Context is everything, and managing it is still work - I haven't quite figured out how to completely remove the human from the loop to make judgements about what is good context and bad context. Sometimes, the slop cannon that is AI will generate way too much extra content, and you have to sort through it to pick out what added context generated is actually useful or should be discarded.

Lastly, even though AI is good at tool use, it doesn't always have the right tools, and a lot of day-to-day apps still aren't AI-native. There are clever workarounds (like what Peter Steinberger has done with OpenClaw by building various custom CLI tools) but they're not native. Products are still catching up. You can try to push against it, but it's hard to swim upstream when the current is hitting you in the face.

Never stop pruning

That is also why I think about my AI setup like a bonsai tree. You're always growing it, adding context, refining skills, building workflows, but you also have to be willing to trim it back. The models get better, the tools change, and the thing you spent a week perfecting might not be the right shape anymore.

Have a low tolerance for sunk cost bias and be willing to keep pruning your setup. Whatever you build today, hold it loosely. What works now might be obsolete in three months, and that's fine.

A note on cost

All of this assumes a pretty healthy AI budget. If I were more cost conscious, I'd take a similar approach but be more intentional about which models I use for what. There's no need to use state of the art for everything. You can swap to cheaper, faster, less capable models for a lot of tasks. Most of it is just getting a feel for where the models trip up, and then going one tier above if you want to be frugal.