I Was Wrong About AI

Timestamps

• 00:00 - Intro
• 01:13 - You're the problem
• 03:58 - How things changed with Agentic AI
• 04:58 - The game changer - The Vault
• 06:36 - How to learn more about using AI
• 07:51 - Goal driven prompting
• 09:25 - Using MCP
• 13:22 - Running Operations Through MCP
• 15:06 - What I believe now
• 15:52 - My 3 Approaches

I used to say AI was going to make developers worse.

I meant it, said it on camera and everything. And I was partly wrong, so let me talk through where I actually landed. It turned out to be a fault in my approach more than a problem with the tool. It matters way more what you're doing with AI than whether you're using it at all.

You're the problem

The fear was that people stop learning the fundamentals.

You lean on autocomplete, take whatever it gives you, and never build a real picture of what's going on underneath. You get 80% of the way to something and don't have the skills to take it the last 20%, which is the hard part, polishing the bugs out and making it production ready. Then you're shipping code you can't explain.

I still think that's a real risk. I'm not gonna pretend I made it up. I was just blaming the wrong thing.

The tool doesn't decide whether you learn. You do.

So I could use an AI tool and learn a ton in the process, and you could use the same tool and learn absolutely nothing. Someone who wants to coast is gonna coast. Before AI they copied off Stack Overflow without reading it. Before that they copied out of the textbook. I remember someone in college turning in a solution written in the wrong programming language, they'd grabbed it from somewhere and didn't even notice it wasn't the language the class was using. The shortcut has always been there. AI just made it quicker.

So lazy will be lazy, that part isn't on the tool. And it's not like the good code isn't real, I've seen it said that up to 75% of Google's new code is AI generated now. These companies aren't shipping slop on purpose, the difference is how it's being used.

The other side of it is what got me. If you actually want to learn, this thing is a really good tutor. You can stop on any line and ask why. Ask it the same thing five different ways until it clicks. Paste in an error and get a real explanation instead of a forum thread from 2013 that ends with "nevermind, fixed it." And it reasons about your actual project, not some toy example, it'll trace a request from where it comes in to where it goes out, spot an edge case you didn't think of, point at the bug. That's the stuff I would've loved when I was starting out.

How things changed with Agentic AI

Way back when ChatGPT first showed up I used it to build a little game, and it was a nightmare.

Part of that was the models being nowhere near where they are now, but a lot of it was my workflow. One prompt didn't get me there, and every prompt after that just added new problems. I'm pretty sure that's exactly where most people bail and decide the whole thing is overhyped.

What changed was agentic AI. Instead of sitting in a browser copy-pasting between a chat window and my editor, the agent could work on the files directly.

That was scary at first, it's changing stuff faster than you can read it, and early on I had it anchored to nothing, no rules, no boundaries, just kind of loose on my code. It also got better the longer I stuck with it, and a lot of that was just me getting better at driving it. I was treating it like a vending machine, put in a prompt, get a result. It's more of a skill you build up.

The Vault

The thing that actually flipped how I work was giving the AI a knowledge vault and specialized skills to drive off of.

I keep all my architecture decisions and the important context about the project in a folder the AI keeps up to date as we go. Then anytime it does something I don't like, I don't just sigh and fix it, I do something with that. Usually I update a skill, since that's how I launch most of my agents, a designer skill, a build skill, whatever, each one carrying the specific context to get the result I want. Sometimes it goes in the vault instead.

That was the shift for me. Pretty much any time something went wrong I could improve the setup so it wouldn't happen again.

And it wasn't one giant CLAUDE.md growing forever. It's specialized spots, the vault documenting the components I have available, a skill holding the actual workflow for building good software. So instead of "hey build me this feature," the skill turns it in to: spec it out, research a few ways to implement it, ask me questions to pin down the spec, build it, add tests, then separately verify the whole thing works. Now there's a multi-step process and it's a lot harder for junk to sneak through.

That's just scratching the surface of structuring your repo, skills, agents, and hooks. I put everything I've worked out over the last six months building my own SaaS in to my Agentic AI course if you want the full setup.

Goal driven prompting

The next thing that moved the needle was goal driven prompting, and it's a little weird.

I'd give it a goal I knew it couldn't currently do, and have it invent the path to get there. This is basically how I built the whole API and MCP layer for my software. Instead of "add the ability to import contacts," I'd hand it the outcome:

I need to launch a campaign to my contacts, so get them imported in to Course Catalyst through the API. If you can't do it yet, build whatever's missing in the API so that you can.

Simplified example, but pointing it at the result instead of the steps worked way better than I expected. It forces the thing to think through the whole end-to-end workflow, because the task literally isn't done until the result happens. When you just list features you tend to come up with nice-to-haves, not the actual path.

Using MCP

The bigger shift was when it stopped living in a code editor and could get in to the accounts I already use.

I could point it at the tools my business runs on and let it read and write real data, pulling notes out of Notion, reaching in to Kit and Stripe, writing straight to my own platform, Course Catalyst. If the end goal is getting everything on to Course Catalyst, it can go grab whatever it needs from wherever it lives.

That's when it stopped being fancy autocomplete for me and turned in to something that helps with the operations, not just the code. And the thing that pushed me to seriously invest in this was a big migration. I was moving a whole business off a few different platforms, and it wasn't just the easy stuff:

• 600 plus lessons, with code blocks and formatting that had to survive intact
• 30,000 contacts
• years of sales and transaction history
• email sequences and automations
• landing pages
• forms and lead magnets
• coupons and discounts
• everyone's product access and enrollments
• all the images and video

I started out doing it with scripts, and I had a working prototype, import the contacts, pick what products they land in, confirm, done. The trouble is a script can't reason. I had both platforms live at once, so the same contact existed on both sides, emails going out from one or the other, and it was way messier than copy data, paste data. When something didn't line up perfectly the script had no idea what to do and I was back to doing it by hand.

So instead I built a skill for the migration. It writes whatever scripts it needs, checks the data on both sides, and flags anything that looks off instead of just handing me a pass or fail. While it was in there it also caught spelling mistakes and clunky wording and cleaned up some of my lesson copy, without flattening my tone in to AI-sounding mush. And when something didn't have a clean one-to-one match, like a couple courses I'd archived, it didn't guess, it laid out the options (import these in to another course, or mark them unknown) and asked me. I just tell it to bubble up the concerns and check with me, and it does.

Running Operations Through MCP

Here's a small one that still gets me. I can describe a whole promo in a couple sentences and it wires the whole chain together:

Using my Course Catalyst MCP, draft a simple thank-you email (~100 words): an extra 20% off Agentic AI for anyone who's gone through my AI Mastery course, expiring Monday 11:59 PM ET, with the coupon code in it.
Make a coupon for 20% off that expires then.
Draft it to everyone enrolled in AI Mastery, minus anyone who already bought Agentic AI.
Before sending, send me a preview email and the count for the send (AI Mastery − people who bought = ?).

It asks a clarifying question or two (which coupon, which tier), then I get the preview in my inbox and read it over. I built the MCP so it has to confirm the recipient count before a big send, just to force it to slow down. And I was careful with anything destructive, there's no delete-broadcast tool at all right now, so if something needs deleted I either soft delete it to a trash bin or go do it in the account myself.

None of that was a feature I sat down and built. I can chain together whatever I need, right when I need it, and invent the next variation on the fly.

What I believe now

Every couple months someone tells me software engineering is dead. I don't really buy it.

Maybe the earlier version of it is fading and some new version is taking its place. That sounds like cringey garbage when I say it out loud, but the point is you adapt to the new environment, same as always. Does that mean you have to use AI for everything? No. Does it mean you should at least be open to it being useful for some things? Yea, I'd say so.

So where do I land. Use AI when it makes sense, don't lean on it as a crutch, and don't skip understanding what it handed you.

My 3 Approaches

I bucket it in to three.

If it's something you understand well, let the AI do it for you. If it's something you don't understand and don't care to, because it's just not relevant to you, let the AI do that too. The dangerous bucket is the thing you don't understand at all that also really matters, that's where you don't want AI driving, you want to be in it.

A few examples of what I mean:

• a basic CRUD API layer is a fancier version of scaffolding, let AI generate it
• a user interface you can check with your eyes, you don't need to know the exact CSS
• processing payments, if you don't understand it and you're having AI build it, you've got a real problem

💡 Tip[!tip]
Not every detail is worth caring about. If something's easy to check, you don't have to know how it was built, you can just look at the result. I can open a page, see it looks right, and measure how fast it loads without reading a line of the CSS. As the tools get better I sweat fewer of those little details and put more of my attention on the higher-level pieces.

The trap is the stuff you can't just eyeball. AI will sometimes do the work wrong in a way that looks completely fine, nothing errors, it just quietly isn't doing what you thought. The person who catches that is the one who knows how the thing actually works.

Here's where it bites. Say it tells me "you've got an N+1 database problem" and I go "no idea what that is, fix it." That didn't actually solve anything, the same pattern is just going to show back up later, and even if I paste it in to a CLAUDE.md I skipped the part where I understand it. So when something like that comes up, treat it as a trigger to go do the research. Then next time you hit a table scan and awful performance, you already have a rough idea how to fix it.

💡 Tip[!tip]
A couple examples of what I mean. It'll happily write code that hits the database inside a loop, one query for the list and then another query for every row in it, which is the N+1 problem. It runs fine while you're testing on ten rows, then falls over once there's ten thousand. Or it'll filter on a column with no index, so the database scans the whole table every time instead of jumping right to the row. Both look totally fine until the data gets big, and you only catch them if you know to look.

For me that means I don't sweat the UI much, as long as it looks decent and stays consistent. But data, money, authentication, that's where I put in the extra effort to really understand what's going on behind the scenes.

I just don't see AI as the thing that ruins that anymore. Used right, it's been the opposite for me. Anyway, that's where I've landed for now. Ask me again in six months.