The Setup That Runs My Businesses While I Sleep

I closed a deal from 10,000 feet last month.

Not on my laptop. On my phone. I texted my Mac Mini a command mid-flight, and by the time I landed, fresh leads were sitting in a Google Sheet, skip-traced and ready for my team to call in the morning.

While that was happening, a second system was editing a video I'd AirDropped before takeoff. Transcribed. Captioned. Color graded. Exported for three platforms. Posted. Original deleted to save storage.

A third system was drafting tomorrow's outreach emails from market research it ran at midnight.

I didn't touch a keyboard for any of it. I was flying a plane.

Stop for a second. Count the tabs you have open right now. ChatGPT. Google Docs. Maybe a spreadsheet where you're manually logging something an API could handle. A Notion page you swear you'll organize this weekend.

You close your laptop tonight and all of it stops. Tomorrow you open it and do the same thing again. And the next day. And the next.

I'm going to show you exactly what the other side looks like. And I'm going to give you enough to get there today. Not next month. Today.

But I need to kill a few sacred cows first.

The Agent Race Is Over

If you're still debating which AI coding tool to use, let me save you the research. Three agent harnesses have been at war for the past year. One of them just won. The other two don't know they're dead yet.

OpenClaw (Cline). Open source darling. Plug in any model you want. The community loves it. One problem: it has the memory of a goldfish. Every session starts fresh. It doesn't know what it built yesterday, what broke last week, or what your project even does. You re-explain everything, every time. That's not an agent. That's a very expensive parrot.

Hermes. Actually built proper memory. Learns across sessions, references past decisions. Real engineering. One problem: it runs on raw API keys. Pay-per-token. Every conversation has a meter running in the background. Use it the way it's meant to be used (all day, every day) and watch your bill climb past your rent.

Claude Code. Persistent memory. Flat subscription. And three recent features that buried the competition:

Memory. Flat rate. Autonomous operation. That's not an incremental improvement. That's a different category.

I Didn't Download a Single App

When I got my Mac Mini, I installed exactly one thing: Claude Code.

Then I told it what I needed.

Python. Node. Homebrew. FFmpeg. Git. Ollama with three local AI models. Database tools. Every dependency, every config file, every system path.

Claude installed all of it. Configured all of it. Verified all of it.

I drank coffee and watched my computer build itself.

Read that again. I described what I wanted my machine to be. Claude made it happen. No Googling install commands. No debugging PATH variables. No "works on my machine" nonsense. One conversation. Fully configured development environment.

Most people think Claude Code is for writing scripts and fixing bugs. That's like buying a Ferrari to drive to the grocery store. Claude Code has full access to your operating system. It installs software, manages files, configures services, schedules tasks, monitors processes, and executes anything you could type into a terminal. Faster than you, because it never has to look up the syntax.

And there's one file that turns it from a powerful tool into a system that knows your entire business.

CLAUDE.md

Drop a file named CLAUDE.md in any folder. Claude reads it automatically. Every session. No setup required.

This file tells Claude who you are, what you're building, and how to work. Without it, Claude is smart but clueless. With it, Claude picks up where you left off like a coworker who was on the project last week.

# CLAUDE.md

## Who I Am
[Your name]. [What you do in one sentence].

## Active Projects
- [Project 1]: [One-liner]. Located at ~/projects/[name]/
- [Project 2]: [One-liner]. Located at ~/projects/[name]/

## Rules
- Explain what you're doing before you do it
- If something fails, diagnose before retrying
- Ask before destructive changes

## Tech Stack
- [Languages, frameworks, databases, hosting, key tools]

Save it. Fill it in. Now Claude knows your context before you type a word.

Problem: close the terminal and today's session disappears.

Fix: a brain/ folder in each project with two files. CONTEXT.md (what the project is, current state, key decisions) and learnings.md (everything Claude has discovered across sessions).

Add three lines to your CLAUDE.md:

## Brain
Read brain/CONTEXT.md and brain/learnings.md before every task.
Update learnings.md after every significant build.

Now Claude writes its own notes and reads them back next session. My foreclosure bot has dozens of entries. Which county changed their site layout. Which API wastes credits on bad data. Which edge cases break the parser.

Claude remembers all of it. I don't have to.

After a few weeks, something happens that'll make you uncomfortable: Claude starts catching things you missed. It references a decision from Session 4 while debugging a problem in Session 30. It avoids mistakes it made two weeks ago because it wrote a note about it at the time.

Your AI gets smarter every single day. While everyone else's resets to zero every time they open a new chat window.

Let that sink in for a second. Then let's build something.

Your First Automation (10 Minutes. No Excuses.)

Stop reading about AI. Build something with it. Right now. Pick the task you hate most. The one you do every week that makes you want to throw your laptop.

$ cd ~/projects/my-automations && claude

Tell Claude what to build in plain English. Be specific about what goes in and what comes out.

Claude writes the code. Sets up dependencies. Handles edge cases. You watch it happen live.

Then schedule it:

$ crontab -e
# 0 6 * * * cd ~/projects/my-automations && python your_script.py

Runs every morning at 6am. You wake up to finished work instead of a to-do list.

Ten minutes. One task eliminated forever.

Now picture doing that thirty times.

Now Build the Brain Behind It All

One cron job is cool. But you know what changes everything? When your AI doesn't just run tasks. It manages them. Knows what's on your plate. Prioritizes. Briefs you in the morning. Follows up at night.

That's not a script. That's an AI assistant. And you're about to build one.

Here's the architecture. Five pieces. All local. All yours.

Piece 1: The Brain Directory

You already built the brain/ folder with CONTEXT.md and learnings.md. Now expand it. Add three more files:

brain/
├── CONTEXT.md          # Who you are, what you're building, current priorities
├── learnings.md        # What Claude discovers across sessions
├── conversation_log.md # Recent interactions (Claude updates this itself)
├── active_goals.md     # Your top 3-5 goals right now
└── preferences.md      # How you like to be briefed, communication style

Every time Claude starts a session, it reads all of these. It knows your goals before you say a word. It knows what happened yesterday. It knows what you care about this week.

Update your CLAUDE.md:

# Mission Control — AI Assistant

## Brain
Read every file in brain/ before doing anything.
Update conversation_log.md after every interaction.
Update learnings.md when you discover something new.

## Role
You are my executive AI assistant. You manage my priorities,
track my goals, and proactively surface what needs attention.

## Rules
- Brief me concisely. No fluff.
- If something is urgent, lead with it.
- Track what I say I'll do and follow up on it.
- When in doubt, ask. Don't assume.

That's it. Claude now has persistent memory, a role, and rules of engagement. You just gave your AI a job description.

Piece 2: The Dispatcher

Right now, Claude does whatever you ask. That's fine for one task. But a real assistant needs to route. "Check my leads" is a different job than "draft tomorrow's content."

Build a simple dispatcher. One Python file:

import subprocess, sys

AGENTS = {
    "briefing": "Give me a morning briefing based on brain/active_goals.md",
    "content":  "Draft content based on brain/CONTEXT.md priorities",
    "research": "Research the following topic and save findings",
    "status":   "Read brain/ and summarize current state of all projects",
}

def dispatch(message):
    # Match intent to agent
    msg = message.lower()
    for key, system_prompt in AGENTS.items():
        if key in msg:
            return run_claude(system_prompt, message)
    return run_claude(AGENTS["status"], message)

def run_claude(system_prompt, user_msg):
    result = subprocess.run(
        ["claude", "-p", f"{system_prompt}\n\nUser request: {user_msg}"],
        capture_output=True, text=True,
        cwd="/Users/you/projects/mission-control"
    )
    return result.stdout

if __name__ == "__main__":
    print(dispatch(" ".join(sys.argv[1:])))

Now you can run python dispatcher.py "briefing" and Claude reads your entire brain, knows your goals, and gives you a morning brief. Different keyword, different agent behavior. Same brain.

Crude? Yes. Functional? Absolutely. And you can make it smarter over time because Claude itself can help you improve the routing logic.

Piece 3: Scheduled Briefings

A good assistant doesn't wait to be asked. It shows up with the answer before you knew you had the question.

$ crontab -e

# 5:00 AM — Morning briefing: priorities, deadlines, overnight results
0 5 * * * cd ~/projects/mission-control && python dispatcher.py "briefing" >> logs/morning.log 2>&1

# 6:00 PM — Evening accountability: what got done, what didn't, tomorrow's plan
0 18 * * * cd ~/projects/mission-control && python dispatcher.py "evening accountability check" >> logs/evening.log 2>&1

Your AI now runs a morning standup and an evening review. Every day. Without being asked. While you sleep, while you eat, while you fly a plane.

Most people open ChatGPT and type "what should I do today?" every single morning. Your system already figured that out at 5am and has the briefing waiting for you.

Piece 4: The Task Database

Markdown files are great for context. But tasks need structure. A simple SQLite database gives your assistant a real task system.

$ claude -p "Create a SQLite database at db/tasks.db with tables for:
- tasks (id, title, status, priority, due_date, created_at, notes)
- goals (id, title, status, target_date, progress_notes)
- daily_logs (id, date, briefing_text, accountability_text)
Write Python helpers to add/update/query tasks.
Update CLAUDE.md to reference the database."

You just asked Claude to build its own task management system. It will. In about two minutes. And then it can track what you told it you'd do, and call you out when you don't.

That's not a to-do app. That's accountability with teeth.

Piece 5: The Overnight Work Cycle

This is where it gets unfair.

# 11:30 PM — Autonomous work cycle
30 23 * * * cd ~/projects/mission-control && python dispatcher.py "Run overnight cycle: draft content for tomorrow, research any open items in active_goals, prepare morning briefing, save all outputs to drafts/ for my review" >> logs/overnight.log 2>&1

You go to bed. Your AI reads your goals, checks what's pending, drafts content, does research, and queues everything up for your morning review. You wake up to a folder full of finished drafts. Not ideas. Not outlines. Drafts.

That's your Mission Control MVP. Five pieces:

You can build this entire MVP today. It took me a Saturday afternoon for the first version. The code isn't complicated. The architecture is what matters, and now you have it.

But here's the thing. This is the starter car. What I actually run is the racecar.

What I Actually Built

I didn't stop at one automation. Here's what runs on my Mac Mini right now:

One Mac Mini. Always on. No team. No SaaS stack. No VA who ghosts you after two weeks.

Read that list again. Slowly. Now ask yourself: how long would it take you to build even one of those?

I'm showing you what exists. I'm not showing you how it's wired together. Not to be mysterious. Because one wrong config and you're debugging at 2am wondering why your cron job just emailed 400 people the wrong thing.

What you got in this blueprint — CLAUDE.md, the brain system, your first automation, and the Mission Control MVP — puts you ahead of 99% of people "using AI" right now. That's real. You can build all of it today.

The distance between that and what I just showed you? An iMessage bridge that uses macOS private APIs. Multi-agent orchestration with conflict resolution. Approval queues that prevent your AI from doing something stupid at 3am. Permission inheritance bugs that no Stack Overflow thread has ever seen. Edge cases that only exist when you're the kind of person crazy enough to run five autonomous agents on a $600 computer in your closet.

That gap is where I live.

Your Move

• Install Claude Code: npm install -g @anthropic-ai/claude-code
• Create ~/CLAUDE.md with the template above
• Build your first project folder with its own CLAUDE.md
• Add the brain system (CONTEXT.md + learnings.md)
• Pick the task you hate most and tell Claude to automate it
• Schedule it with cron so it runs without you
• Notice what else you want to automate (this is where it gets dangerous)

Fair warning: step 7 will ruin you.

Once your first cron job runs at 6am and you wake up to finished work, something breaks in your brain. You start looking at every manual process in your business like it personally offended you. Every repeated task. Every copy-paste. Every "I'll get to that later."

You'll never look at your workflow the same way again. And you'll wonder how you ever tolerated doing it by hand.