The Five-Layer Stack: How to Work With AI

Everyone’s teaching prompts. How to ask ChatGPT the right question. How to get better outputs. How to be a “prompt engineer.”

I spent time on that too. And it’s useful — to a point. But it’s about 30% of the work.

The Stack

After a year of working with AI every day — not dabbling, not experimenting, but actually running my business through it — here’s what I’ve found works:

• A wiki for context — the things that don’t change. My philosophy, my positioning, my methodology. The stuff that makes AI understand me instead of giving me the same generic answers it gives everyone else.
• A database for state — the things that change daily. My clients, my invoices, my projects, my deadlines. The operational reality of what’s actually happening right now.
• Git for the trail — everything that happened, when it happened, and why it changed. The version history that gives AI memory across sessions and gives me forensic-level diagnostics when something goes wrong.
• My judgment — twenty-six years of pattern recognition. The “this feels wrong” that no AI can replicate, no matter how good the model gets.
• AI for velocity — the execution speed. The grunt work that used to fill my afternoons.

Each layer does what it’s good at. Nothing more, nothing less.

This works with any AI. ChatGPT, Claude, Gemini — it doesn’t matter. The stack is the architecture. The AI is just the engine. I use Claude.ai for reasoning through problems and Claude Code for building things. Different tools, same stack feeding both.

Why Most AI Usage Stays Shallow

Without the stack, the pattern is predictable.

You open ChatGPT. You ask a question. You get a generic answer. You refine. You prompt again. You get something slightly better. You copy it out, edit it heavily, and use maybe 30% of what it gave you.

Next week, you do the same thing. From scratch. No memory. No context. No compounding.

This is why people say “AI is overhyped” or “it’s just a toy.” They’re not wrong about their experience. They’re wrong about what’s possible when you put some architecture around it.

The 70/30 Principle

Here’s something I learned the hard way.

The process I follow looks like this:

1. I give AI a task
2. I notice where it stumbles or asks questions
3. I fill that gap in my documentation
4. Next time, I don’t get that stumble
5. I compound this over months

Eventually a high-level instruction triggers the right cascade of understanding. “Write the Monday client email” just works — because the context already exists for what that means, what tone to use, what information to include, who the client is, and what I did for them this week.

It’s easier to chase the magic prompt than to do this work. That’s fine — it means the gap between those who build context and those who don’t keeps getting wider.

What Each Layer Actually Does

Wiki (Context)

This is my institutional memory. Not documentation for documentation’s sake — documentation that makes AI useful.

• Who I am and what I believe
• How I talk to clients
• What my services actually include
• The methodology behind what I do

Without this, every AI interaction starts with “I’m a small business that does X and my tone is Y and my clients are Z…” Every single time. I got tired of that conversation by about week two.

The critical rule I learned: no metrics in the wiki.

The moment you put “currently at a certain MRR” in your context document, you’ve created a lie waiting to happen. Next month the number changes. The wiki still says the old number. Now you have no source of truth.

I keep metrics in the database. The wiki holds things that don’t change — or change so rarely that I’ll notice when they do. “One Michelin star, working towards three” can stay true for years. Revenue figures are stale by the next invoice.

Database (State)

This is operational reality. The numbers, the deadlines, the facts.

• Which clients are active right now
• What’s overdue
• Who I need to contact
• What’s been paid

AI can query this. “Show me clients I haven’t contacted in two weeks” becomes possible when the data actually exists in a structured form. I built this with Django, and it’s the backbone of how I run the business day to day.

Git (The Trail)

This is the layer I didn’t plan for. It emerged from the work itself.

Every change I make goes through version control. Every correction, every new piece of documentation, every client deliverable — timestamped, searchable, and permanent. It’s a complete operational history of the business.

Here’s why that matters: in December, my rankings for a key search term dropped from position 5 to position 49. With any other setup, I’d have been guessing. Running crawl reports. Checking for algorithm updates. The usual.

Instead, I searched the commit history. Found the exact commit where I’d removed fifteen blog posts in one go. Saw the exact date. Saw the exact diff — which pages were removed, which internal links broke, which topical signals disappeared. Diagnosis in five minutes, not five days.

The wiki tells AI what I believe. The database tells it what’s happening now. Git tells it what I actually did — and in what order, and why things changed. It’s the difference between an AI that sees a snapshot and one that understands momentum.

And here’s the part that surprised me: faithful daily work leaves residue. The commit messages from six months ago weren’t written as documentation. They were just good practice — clear descriptions of what changed and why. But they’ve become searchable institutional memory. The trail compounds into capabilities I didn’t plan for.

Your website should have version control too. WordPress can’t do this — it tracks content revisions, but not templates, not routing, not schema, not build configuration. The trail is a consequence of the stack, not an add-on.

Human (Judgment)

This is the layer that AI can’t do. The pattern recognition. The “something’s off here.” The relationships.

• Does this feel right?
• Is this client actually happy or just being polite?
• Should I take this project?
• What’s the real problem underneath the stated problem?

AI (Velocity)

This is the multiplication layer. Once the context exists and my judgment has decided what to do, AI executes at speed.

• I draft the email in thirty seconds instead of thirty minutes
• I build the report by pulling from the database
• I create the content in my documented voice
• I research the prospect and get a summary of what actually matters

The grunt work. The stuff that used to fill my day and keep me from the work that actually moves the business forward.

The Compound Effect

Here’s what happens over time, and this is the part that’s easy to miss if you give up too early.

Week 1: I’m explaining everything. Every prompt is long. Every output needs heavy editing. I’m wondering if this is actually saving me any time at all.

Week 10: Common tasks just work. The context is built. I’m adding to it, not recreating it. I’m starting to feel the velocity.

Week 50: High-level instructions trigger cascades of understanding. “Prepare for the client meeting” pulls context, checks the database, reviews the commit history for recent work on that client, drafts the agenda, and identifies issues — because all five layers exist and feed each other.

What This Means for You

You don’t need to build what I’ve built. I’ve spent a year on this and it’s specific to my business. But you need something.

I’d start simple:

• One document that describes how you talk to clients and what you stand for
• One spreadsheet that tracks your operational state — who’s active, what’s due, what’s overdue
• Version control on your website — even if it’s just knowing what changed and when
• Your judgment about what matters, what feels right, and what doesn’t
• AI to execute once the first four exist

The document grows. The spreadsheet gets more useful. The version history becomes searchable intelligence. Your judgment gets augmented by data you can actually see. The AI gets better as context accumulates.

Context for depth. Data for truth. The trail for memory. Judgment for decisions. AI for speed. In that order.