Claude Code, chat, and Projects

It's a designed filing system that lives on your own computer. At the bottom of it, it's a compilation of files: text files, Markdown files, JSON files, arranged into a structure where each part has a job.

At the top sits the root file, the one that tells Claude how you work. Under it sit the rules, the memory, the skills that do the work, and the pages and data your business runs on. You adapt any of it to fit your business, because you own it.

Claude reads the structure when you open it, so it already has your prices, the way you write and who your clients are before you type anything.

The download is called the Repo(sitory). The root system is what you build with it: a CRM, a course platform, a quiz, the emails that go out, and the sides of your life you want counted too. 🧠 💪 ❤️ ✨

Claude's memory is genuinely useful and it keeps getting better. It builds entries from what you talk about, and you can open settings and read or edit every one of them. If you use Claude daily, turn it on.

The difference is how much of it you can change. In the root system you decide how it remembers and what it remembers, and you can read every line: the rule about what you charge, the guide for the thing that broke, the skill that writes your invoices the way you want them written.

You can see what a chat tool remembers, and you won't be able to edit the way it remembers or what it fetches. Here you create the structure, and the memory system is yours to change. If you don't want it recording patterns about you, delete that file and it stops.

Both are worth having. The root system sits on your own disk, so you can copy it, back it up, and take it with you if you change tools.

The goal here is that you own your life and your AI. The files sit on your machine, the accounts are in your name, and you can change any of it on a Tuesday afternoon without asking anyone.

A subscription product has a different job to do. It has to be worth renewing, so it gets built to be used inside itself, and the companies doing that well are doing exactly what they should.

New features land in those tools every week, and plenty of them are aimed at people who enjoy new features. What's in the Repo(sitory) got built for a quality of life: fewer hours spent doing the same thing twice, and a business that still works the way you left it in 3 years.

No. Keep the chat for the jobs it already does well: a quick question, a draft, a think-through that does not need to land in a file.

A root system runs on Claude, so the subscription is part of the setup. The change is at the start of the conversation. Claude Code reads the structure first, so you're not describing your business from scratch again.

You could, honestly. A founder who sat down today could have a working CRM by dinner and a course platform by the weekend. It would run, it would look fine, and on day one it would do roughly what mine does.

There are 1,343 commits in mine since 15 January. What that afternoon doesn't buy is the other 1,342. Most of them are corrections. They're things that broke, in front of real people, and had to be fixed so they never happen again.

You can't ask for any of those in advance, because you don't yet know they exist. You find them by having them happen to you, and every one of them costs a day you weren't planning to spend.

That's what seven months of daily building actually is. A slow accumulation of things you'd only know if you'd already got them wrong. 🥴

Every one of them is written down. There are 229 written session records behind this system, and 136 of them list what went wrong that day and the rule that came out of it. 227 skill files and 132 written guides ship inside the Repo(sitory), and most of them exist because something went wrong once.

Nothing takes it to zero. Every model invents things, Claude included, and it sounds exactly as confident when it does.

Hallucination is just creativity. When the model doesn't have the fact, it fills the gap with something that fits. Give it the fact and there's less left to invent.

When you manage context correctly, you can pretty much eliminate hallucinations. I really don't get hallucinations anymore. That holds when it's reading my files. It stops holding the moment I use it like a Google search and ask it about the world from memory.

Most of what's in the Repo(sitory) is that work already done, so the facts are sitting in files before the question gets asked. The checks that read what gets written before it ships are in there too, so a wrong claim gets caught by something other than your own attention.

A Project is a good tool. You give it standing instructions, drop in the files it should always know, and it keeps its own memory apart from everything else you do. For one defined piece of work that's often all you need.

You can read what a Project remembers and you can change its instructions, and the way it remembers and what it pulls in stays the tool's to decide. What comes out comes out in the chat, for you to copy where it needs to go.

The same instructions in a root system live in files you can copy, version, and hand to whoever takes over your operations. What comes out of a conversation lands where the work is: a file, a row in the CRM, a page on your site, there for the next conversation to read back.

Cowork is very good, and both it and Claude Code live in the same app now, so the difference isn't the terminal.

The difference is where the work actually happens. Cowork runs your task in an isolated environment on Anthropic's servers, and it reaches your computer through the desktop app for the files you grant it. Claude Code runs on your own machine, against your actual files, in your actual setup.

That matters for a root system because the structure is doing real work while you build. The rules load from your own files, and the checks that catch a wrong price or a private link before it ships are small scripts that run where the files are. Handing a task to a contained environment and running inside your own system are two different jobs.

Cowork is a good place to hand off a piece of work, and companies get demoed in it for exactly that reason. The system it reads is still yours: the rules, the guides, the 7 months of corrections.

Uploading works, and for a single document it's the fastest thing you can do.

What you get is a copy that sits still. The version you save on your computer tomorrow isn't the one you uploaded, so you attach it again, and again.

A root system is live. Claude opens the current file, changes it, saves it, and the change is there next week whether or not you remember to attach anything.

A skill is a folder with instructions and scripts that loads itself when it's relevant. That's the same shape a root system is built from, and it's an open standard now, which is good news for everyone.

My own business runs on 82 of them, written over 7 months and wired to the data, the pages and the money they act on.

So skills are the right idea. The work is in having enough of them, each one correct, and all of them knowing your prices, your voice and each other.

Connect them. Claude reaches real accounts now, it asks permission at each step, and the company building that takes the care seriously.

Access is the easy half. The judgement about what happens once you're in there is the half that costs days.

A connector does exactly what you asked it to. Ask it to add one guest to an event the wrong way and it silently resets everyone else's RSVP. The rule that stops that sits in the root system, and it fires before the calendar gets touched.

Claude can run scheduled work in the cloud, and for a recurring prompt that's a fine place to put it.

The 47 background functions in this system are small pieces of software running on your own accounts. One takes a payment and gives the person access, another sends the welcome email, a third writes the weekly note about what changed.

They keep running when nobody's logged in, and what they produce lands in the business rather than in a chat: a row in your CRM, an email in someone's inbox, a page that updates itself.

Yes. That's the good part.

It's 3,787 files: 82 skills, 230 changes to the database, 47 functions running on their own, and 158 daily logs with none deleted.

Every one of those is a plain file. You open it, read it in English, change a line, and the system behaves differently tomorrow. Every file opens in a text editor, and it's yours whether or not you're logged in to anything.

That's also why it travels. It copies to a new laptop, and it hands over cleanly to whoever runs your operations next.

Yes, all of it, in plain English.

Claude lets you open settings and read what it has stored, which is more than most software offers. Here there's no settings page in between, because the memory is files: what's true about your business, what changed today, and what got learned along the way.

You read them like a notebook. What you charge in one file, how you write in another. If a line is wrong, you change the line.

Deleting a file deletes it from the system that reads it.

No, and the whole design assumes you're not.

You'll be doing something that looks technical: setting up the structure and running a few commands. What makes it doable is that the instructions are written for someone who's never done it, and Claude is the one typing.

The 132 written guides exist because someone got stuck at that exact step and the answer got written down. When you get stuck, you ask the system, and it reads its own guide back to you.

The skill that actually matters is being able to say clearly how your business works.

What you buy from me is the head start, and then the thing is yours. It sits in your own files, on your own accounts, and costs about €25 a month to run. You open it up and change it, or you ask it to change itself.

If you stop paying me, nothing switches off. Your Claude subscription keeps it thinking, the €25 keeps the database and the site running, and both of those accounts are in your name.

The standard shape of AI implementation work is a setup fee and then a retainer, which means the person who built it keeps holding your context, and you keep paying to reach it. Owning the files takes that arrangement off the table.

With the free Service Map. Sixteen questions about how your business actually runs, and where your time, your money and your energy are going. What comes back is your business across five stages, your own tools placed where they sit, and what each one is costing you.

Then go and watch a build. The full ones are on YouTube, start to finish, nothing held back, including the parts that go wrong on camera. 🎥

If you want to build it yourself from those, build it yourself from those. That's what they're there for.

The same folder in Grok is on its own page. More models will sit next to it, from this home.