Stop Chatting With AI. Start Building With It.

Here’s a question I want you to think about: when you start a conversation with AI, what does it know about your business?

Nothing. It knows absolutely nothing.

You’re starting from zero. Every single time. And if you’re just “chatting” with AI - asking questions, getting answers, closing the window - you’ll start from zero forever.

The Chat Trap

It’s easy to fall into the habit of using AI like a search engine. You type a question in, you get an answer out, and you move on.

That works for one-off queries. “What’s the capital of France?” doesn’t need context. But anything about YOUR business - your clients, your positioning, your voice, your methodology - needs context that doesn’t exist unless you provide it.

So you find yourself explaining. Every time. “I run a small consultancy that does X for Y clients and my tone is Z…”

That’s not compounding. That’s Groundhog Day.

The Session Protocol

Here’s what compounding actually looks like in practice:

Next session, I load the updated documents. The system knows more than it did yesterday. The work builds on previous work. The context accumulates.

This is so simple it feels obvious. But it requires discipline, and that’s where it falls apart.

The System Writes Its Own Manual

I started by asking mine a simple question: “What do you know about my business?” The answer was nothing. That was my baseline. Then I asked: “What would you need to know to be genuinely useful to me?” It told me. Voice and tone. Client information. Service methodology. Pricing. All the things I’d been explaining every single session - those were the things that should have been in a document from the start.

But the real trick was asking it how to organise that document. I said: “How do I give you the most context with the most brevity so you don’t lose the signal?”

That question changed everything for me. There’s a tension between context and noise. Load too little and the system is generic. Load too much and the important stuff drowns in detail. Claude Code understands that tension better than I do - it knows what it can absorb, what it skims past, what makes it sharper versus what makes it slower.

My core context document has been rewritten dozens of times. Not by me sitting down and restructuring it - I just ask Claude Code after every few sessions: “What’s bloated? What’s missing? What could be sharper?” It edits its own instructions. It tells me when something is redundant or when a section has grown past the point of usefulness.

The system improves itself. Claude Code helps me compress and refine the very document that makes it more effective. Every revision makes the next session better.

And here’s the discipline that makes it work: Claude Code will happily create documents all day long. Left unchecked, you’ll drown in files that nobody reads and the system can’t usefully load. The signal disappears into the noise.

So I prune. Ruthlessly. I cull pages that overlap. I merge documents that say the same thing differently. I ask Claude Code: “Is this section earning its place, or is it just taking up space?” If a page hasn’t been useful in three months, it goes. If two pages cover the same ground, one gets deleted. If a section has grown bloated, I compress it.

The goal isn’t more documentation. It’s better signal. Fifty pages that the system can load and act on immediately beats five hundred pages of context it has to wade through.

And not all fifty load at once.

The system doesn’t need everything at once. It needs the right context at the right time. That’s the difference between a system and a dumping ground.

If you don’t have context documents yet, your first session should create them. Ask Claude Code what it needs to know. Let it help you build the foundation. One good hour now will save you hundreds of hours later.

7 Months of Compounding

I’m not theorising here. I’ve been doing this since July 2025.

In month one I had a handful of saved changes to a blank project. A context document that barely knew my name. Every session started with me explaining the basics all over again.

By month two I’d made hundreds of changes. The context document had grown. The system knew the businesses I serve, my tone of voice, my service methodology. My sessions started producing real work instead of burning time on orientation.

By month seven I was shipping more in a single month than I had in the first three months combined. Not because I was working harder - because every session I’d ever had was building on every session before it.

Here’s what exists now, 7 months in:

That’s compounding. Not a productivity hack. Not a prompt template. A system where every session makes the next one more valuable.

The difference between month one and month seven isn’t talent or tools. It’s just discipline applied consistently. The same discipline that turns a git history into business intelligence and a pattern library into taste.

Start Today

You don’t need a complex system to get going. But you do need more than one document. A single file trying to hold everything becomes the dumping ground I warned about earlier. I’d think in terms of a small collection of context documents, each with a clear purpose:

1. A core document - who you are, how you work, what matters right now
2. Client or project documents - one per client, one per major project, loaded when relevant
3. Process documents - how you do specific things, loaded when you’re doing them

I’d start with the core document and one client document. Add more as the work demands it. The system grows because the work grows - not because you sat down one weekend and planned an elaborate filing system.

The compounding starts the moment you stop treating every session as session one.

Read more about the system:

• The Five-Layer Stack: How to Work With AI
• The Atomic Commit: Why Your Git History Is Business Intelligence
• Ingeniculture: Why the Room Matters More Than the Model
• The Magic Word

If you want this kind of thinking applied to your business — here’s how I work with clients, or get in touch.

Load context. Do work. Update context. Repeat. That’s how sessions compound. I’ve since given this practice a name.