Five Paradigm Shifts You Need to Embrace About AI

I was in a conversation the other day where we were talking about AI. Pretty much every conversation I have, with just about everyone, is about AI right now.

But this one was about how hard it is to actually work with these tools. All they hear about is the expense ("everything starts for free, but it isn't really usable until you're paying $200 a month") and the inconsistency ("I ask it the same thing two days in a row and get two different answers").

And I said, oh, now we're talking about the good stuff.

And then I said, here are my five biggest takeaways. The paradigm shifts you need to embrace. The stuff that, once understood, makes everything else make sense.

1. Design Time versus Run Time

A lot of the time you think about AI as the super-smart engine that's going to solve every problem. So you bake it into the product. You bake it into all your workflows. You want AI to do everything.

When you do that, you pay the price. And every time it comes up with an answer, the answer can be different. So I don't recommend it. That's using AI at runtime, and I find you can shrink runtime AI usage down to a tiny, tiny little function.

What you really want is to use AI at design time. That's way before you build the product, when you're working through all of the analysis, figuring things out, planning, doing the algorithmic design. Use AI then, because that's a one-time cost. And once you're done with it, it's a lot easier to bake that into deterministic code downstream.

I wrote about the distinction itself in There Are Two Kinds of AI Work, and the specific architecture that cut one of my AI bills by about 40% in Why Your AI Bill Is Too High.

2. Decision Making / Discernment over Prompts

When people started talking about prompts and publishing prompt libraries online, it was like trading incantations at Hogwarts. Right? You need the special words, in a special order, pronounced a certain way, and then everything will be okay.

But that was never reality. And it's even less true now, because these models have gotten so much more capable, so much smarter. You don't need to worry about the exact words you use. You don't need the perfect script.

What you need to worry about is the intention. What's your goal? How do you think about things? Where does your discernment come in? How do you want decisions made? How do you evaluate that a decision is a good one? That's the content you want to give an LLM. Not better words. Your judgment.

I made the core case in Stop Giving Your AI Better Prompts. Start Giving It Your Decision-Making. and showed what it looks like in real engineering, where encoded decisions keep AI from quietly creating technical debt, in How to Adopt AI Coding Without Technical Debt.

3. Feedback Loops (Evals) for All

Dan Ariely wrote a book called The (Honest) Truth About Dishonesty. It's also a documentary you can find on Apple TV. There's one key message in it, and I've shortened it, but it goes like this: first we lie to ourselves, then we lie to others.

The dynamic is simple. We don't start out evil. We don't start by lying to other people. We start by quietly not telling ourselves the truth.

LLMs do the exact same thing. They will cheat. If you tell a model the whole point is to get a better grade, it will change the entire scoring rubric and lower the bar to get one. It will improve its score by moving the criteria. And you sit there thinking, this is insane, how is this even happening?

So the truth is you need a completely different model for how you evaluate the work AI produces. You cannot ask the author to judge its own work. Ask an LLM "is this good?" and it will tell you, yeah, it's great. Every time.

What you do instead is build a framework. A harness. A feedback loop with a rich rubric, where one engine measures another, one set of agents grades another set, and the score and the feedback flow back to whatever is being created. That's the work.

I wrote about why that harness is the real craft in The Harness Is the Craft, the loop you can actually run on your own apps and content in The 4-Part Loop That Eliminates AI Slop, and why I never let a model grade its own work in Why I Never Let AI Grade Its Own Work.

4. Conversations is King

By the time I got to number four, I could feel I was in flow, and that this conversation could go on forever. So I started to slow down and wrap up.

When I say conversation is king, here's what I mean. Stop running to an LLM to get an answer. Start running to it to get a question.

Use the LLMs, Claude, Codex, Perplexity, ChatGPT, any of them, to ask you questions. Ask them to push back on your ideas. Ask them to challenge your thinking. The more conversation you have, the richer and deeper your own thinking gets.

When you run to an LLM for an answer, you start giving away your thinking power. That's the one thing you don't want to do.

I laid out the actual sequence I use in Ten Conversations to Have With Claude Before Vibe Coding, and the posture shift that makes those conversations work in Use Claude to Get You Questions, Not Answers.

5. Knowledge is Built, not Stored

My last point might be the most controversial, because it sounds a little like Cyberdyne Systems and Skynet. If you really want to embrace AI, you have to help it create new knowledge.

This isn't a database. It's not a big database in the cloud where you stuff things in, and then someone else asks questions about whatever got stuffed in, and it comes back out. When you do that, you're treating AI like another search engine. You're treating it like Google.

When you get deep into what's actually going on here, you realize you can give AI building blocks. Your particular building blocks. You can build systems out of them, and then the AI can take unique new paths through those building blocks and emerge with new observations, new data, new takeaways.

And it's incredible when that happens, because now you have it doing really intelligent and capable things for you. Not just being your little assistant.

I made the full argument in Knowledge Isn't Stored. It's Built.. And for a version most businesses can use right now, your ticket system already records every escalation and bottleneck with timestamps, and AI can assemble that into a map of exactly where automation will pay off. No interviews, no opinions, just the data. That's in How to Use Process Mining to Find What AI Should Automate.

The thing underneath all five

Notice what's missing from this list. Not one of these observations is about the model. They're about how you work with it.

The hard part was never the technology. The hard part is getting your own expertise out of your head and into a form the model can use. Do that, and the cost drops, the answers steady, and the good stuff starts.