Build your own AI operating system in Claude Code — a step-by-step guide

This is the version you keep open while you build. You open it while setting up your own AI operating system in Claude Code, check the order of the steps, and tick off what already stands. Each step has two parts: what you do and what you should see once it worked.

One rule up front, because it comes back at every step: think first, reach for the tool second, and take small steps instead of one big leap. Don't build everything on the first pass. Start with context and one or two skills you will actually use, then add the rest as you go.

---

Before you start: two terms and one warning

Two words that come back throughout this guide:

• Claude Code — the tool where the Claude model works on your machine: it reads files, runs steps, and uses other programs. Here we use it not for coding, but for running day-to-day work.
• Agent — a model that acts on its own: it gets a goal and decides for itself which steps to take, instead of waiting for every next instruction.

The system you're building we'll call your AIOS (from AI operating system). It's not an operating system in the Windows or macOS sense — it's one project that knows your business, has access to your tools, and repeatedly does your work for you.

A fair warning before you start: productivity drops before it rises. Setup takes time, and you're learning a new way of working. The worst moment always comes right at the start — exactly when it's easiest to quit. Don't give up after day one. And remember the obvious truth that's still true: a system only pays off once you use it. Setup you never return to just becomes a nice-looking folder.

Step 1. Sketch your tool map on paper

The starting point is deliberately analog. Don't open any program yet. Take a sheet of paper, or open a blank document, and lay out your work across seven areas that we use as the skeleton:

1. revenue
2. clients
3. calendar
4. communication
5. tasks
6. meetings
7. knowledge

These are seven "buckets" that catch almost everything you do. They fall into four bigger groups: operations, communication, data, and planning. Next to each area, write down which tool you use — where you keep tasks, where your calendar lives, what you record meetings with.

What you should see: a sheet with seven areas, each with a tool name next to it. That's your map of what the system will later connect. If you miss something, no drama — you can always add it later.

Step 2. Set up the project skeleton and the CLAUDE.md file

Only with that map in hand do you create the project in Claude Code. At its heart sits one file:

CLAUDE.md

This is the "master instruction" for the whole project. It describes what your system is, what lives in which folder, and when it should reach for a given skill. The system reads it at startup to know where everything is.

Next to it, set up three folders:

• context — what the system knows about you and your business
• decisions — a log of important calls, so the system remembers what you already settled
• references — material to look up

What you should see: a project with the CLAUDE.md file at its heart and three folders beside it. Every time you add a new folder or file, add it to CLAUDE.md too — otherwise the system won't know it's there.

Step 3. Onboarding through conversation — the seven-question interview

You don't fill the folders by hand. Onboarding starts as a conversation. You run a prepared procedure, and the system walks you through a seven-question interview, then writes your answers down as its own context. It's a bit like a new employee's first day.

The first three questions worth knowing ahead of time:

1. "Who are you, what do you sell, and to whom?" — don't hold back words here; the more context you give, the better the system will understand you afterward.
2. Paste one or two things you've written recently, unedited — this is how the system learns your writing style and tone.
3. Your two or three top priorities for the next 90 days — what you're actually working on right now.

The remaining questions go deeper into how you operate. You answer all seven.

What you should see: at the end, the system reports that day one is done — it now knows who you are, what you sell, what matters this quarter, and how you sound. Test this right away with a practical question, for example "what should I focus on this week?". If the answer is grounded in your actual situation instead of generic — you have the first of four pillars: context.

Step 4. Save your first skill

A skill is a reusable instruction written as a plain text file. The best analogy is a recipe: you write the procedure once, and afterward you just say "bake this cake" and it happens.

Pick one thing you do over and over (a LinkedIn post, say), and write down its sequence once. Each skill is one text file with a clear structure.

At the top, in a short header, two key things:

• name — what the skill is called
• description — what it's for or when to use it

The system recognizes which skill to use from that header. When you ask for a LinkedIn post, Claude Code scans all your skills but reads only these short headers — name and description — and picks the matching one. That's why the description has to state clearly when to trigger that skill.

Under the header you describe the rest:

• what the skill does
• sometimes also what it doesn't do (so the system doesn't wander outside scope)
• and then the steps, in order — step one, step two, step three

What you should see: you say "write me a LinkedIn post," and the system reads its recipe and runs the whole procedure the same, proven way. When you want to change something, you don't start from zero — you edit one line in the recipe ("use two eggs instead of one"), and the change just works the next time you run it. If none of your skills match the request, the system falls back on general knowledge.

Some skills you'll pull from ready-made libraries and add your own flavor to. One caution: watch where you source them from, and check that nobody's slipping you a skill with harmful content. Since a skill can act on your behalf, treat it with the same care as any program you let into your work.

Step 5. Connect your tools — MCP, API, or the browser

You already have context and a first skill. Now come the connections, because without them the system knows you but can't reach your data. Claude Code on its own can basically only search the internet, and your most important data isn't public — it's in your calendar, your inbox, your task system, your meeting notes.

You connect the tools from your Step 1 map one at a time. There are three routes:

• MCP — a standardized way for a tool to expose its data to an AI system. The system will usually suggest this as the fastest route by itself, if a ready-made connector exists for that tool. The downside: every connector you load into the project eats some of the system's "working memory" (people talk about token usage — the units the model uses to measure how much it can hold at once).
• API — the interface programs use to "talk" to each other; a leaner route. In practice you tell the system something like:

I want to connect to this tool through its API, since that's leaner than a ready-made connector; go through the tool's documentation and save a reference file in the project with all the addresses we'll need.

• Browser — as a last resort, when a tool has neither a ready-made connector nor documented endpoints, the system can drive it through the browser, clicking the way you would.

What you should see: light, working connections to a handful of your most important tools. Don't connect everything at once — start with a few things you use most often (tasks and meetings, say), and add the rest over time.

Step 6. Turn on the rhythm — local and cloud routines

The fourth pillar is rhythm. You build it with routines: scheduled commands the system runs on its own, on a schedule — every morning, on chosen days of the week, at regular intervals. A routine is nothing complicated: a saved command that, at a set time, gets "typed" into the system as if you'd typed it yourself and hit enter.

One distinction that's easy to trip on:

It's the cloud routine that makes the system start to feel like a staff member available around the clock: you get a finished summary in the morning, even though nobody clicked anything overnight.

A fair limit, so you don't plan beyond your means: the number of routines that can run in the cloud is often capped by your subscription plan. On one of the pricier plans (around two hundred dollars a month, for example), you can run something like a dozen or so remote routines a day at once. That's a specific number for a specific plan, not a general rule — check what yours gives you.

What you should see: a finished routine result waiting in the morning, even though nobody ran it by hand overnight. Keep in mind that every conversation with the system is separate — if a routine set something up in one window, the system in a different window doesn't know about it by default, until it checks for itself. That's a feature, not a bug.

How to check that it's working

Two tests from the article that check the whole system.

The context test. Open a new conversation with Claude Code and ask a question about your work.

• If the system answers like someone who met you five seconds ago — context is missing.
• If it answers like a colleague who knows your situation — you're on the right track.

The four-pillar checklist. Once the system is standing, ask it directly which of the four areas it's strong in and where it has gaps. Four pillars, built one on top of the other, in this order:

1. context — what the system knows about you and your business
2. connections — access to your tools and data
3. capabilities — what the system can do with that data
4. rhythm — what happens on its own, on a schedule

The order isn't random: there's no rhythm without connections, and no capabilities without context.

---

The biggest takeaway here isn't technical. You don't have to build everything on the first try or reach perfection. Start small — with context and one or two skills you'll actually use — and grow the system as you go, because it learns alongside you. Open a blank page and write out your own seven areas. That's the whole first step, and the only one you need to start today.