The Hive Mind Template

This file builds a system that finds what moves the needle for your business and makes sure you act on it. The base is a second brain for your AI: plain text files it reads at the start of every session, writes to as it works, and improves overnight. The top is a profit engine: it learns your real numbers, names the one thing holding revenue back, and picks your needle-mover every morning.

You will go from nothing to a working loop in under ten minutes once your tools are installed, to a self-learning system in about two months of light habit, and to the profit engine about 45 minutes after that. Free. You build it. Your numbers stay on your machine.

Two ways to use it. The fast way: copy the Boot Prompt below into your AI (Claude) and let it drive; this file contains a machine-readable manifest of every file to create, so your AI can scaffold everything and hold you at each gate. The manual way: scroll the phases in order, create each file by hand with the copy buttons, and check off each phase's done-when list. Your progress saves in this page automatically.

This is File 2 of 2. The full explanation of WHY every piece exists (with diagrams and a live demo of the loop) is in the companion: hive-mind-playbook.html. You do not need it to build; you will want it to understand.

Before you start

You need three things. All three are free to start:

Nothing here can break your computer. Everything lives in one folder you can delete.

How long it takes: under ten minutes, once the tools are installed. Installing Claude Code and git the first time takes 20 to 30 minutes. Do it the night before if you want the morning to feel fast.

Three questions people ask

Can I use a different AI? The kit is built and tested for Claude. The manifest is plain JSON any capable AI can follow, but the prompts are written for Claude.

Do I need Hormozi's books? No, not to start. Every worksheet ships with EXAMPLE numbers you replace with your own. The books make the worksheets sharper; the kit works on day one without them. When you are ready, knowledge/hormozi-shelf.md (built in Phase 5) lists every source with a link, and two of the rows are free.

How do I know it is working? On day 5 you ask the brain to grade you. On day 30 you make it prove itself. Both prompts ship in this template, in plain English. And if the loop ever goes quiet, prompts/stalled.md finds the first broken piece in five minutes.

Stalling is normal. The restart prompt finds where you left off; nothing is lost.

What you are building

Second brain: the files and the links you write. Your AI reads them at the start of every session and remembers.

Third brain: the monthly pass where the AI reads the whole vault and finds the connections nobody wrote down.

Profit engine: the Hormozi-worksheet layer that turns the brain into a daily pick of what moves revenue.

This kit builds all three, in that order. Your AI has gates. These checks are yours.

The system you are building

Your AI is brilliant inside one conversation and amnesiac between them. The fix is a folder of text files plus two rituals:

The rituals: read status before doing anything, and close every session with three lines and up to three lessons. Everything else is automation wrapped around those two habits. Git makes it versioned and portable; plain text makes it yours forever.

The boot prompt

The fast way, step by step:

1. Save this file to your computer. In your browser: File, then Save Page As.
2. Open Claude.
3. Attach this file to your message. Use the paperclip (or plus) button and pick the file you just saved.
4. Copy the Boot Prompt below, paste it into the same message, and send.
5. Answer the five questions Claude asks you.
6. Claude builds the Crawl phase and stops at the gate. That stop is on purpose.

The manual way needs none of this. Scroll the phases in order and use the copy buttons.

You have been given "hive-mind-template.html", a build kit for a
persistent second-brain system. Do the following, in order:

1. Read the JSON manifest inside the element with id "hive-manifest".
   It defines 8 phases (crawl, walk, run, fly, profit, one, see, wire).
   Each phase
   lists files to create; every file's "contents" is an array of lines
   you join with newlines. Each phase has "done_when" gate checks.

2. Interview me briefly (5 questions maximum): what my work is, what
   I want my AI to remember between sessions, which tools I already
   use, how many minutes per day I will honestly spend, and what to
   name the project folder.

3. Scaffold the CRAWL phase only: create the folder, git init, write
   the crawl files, adapting the template placeholders to my answers.
   Do not create later-phase files yet.

4. Walk me through my first session ritual once, live: read STATUS,
   do one small task, close with the three-line log.

5. STOP at the crawl gate. Show me the done_when checklist and do not
   scaffold WALK until I confirm every item is true. Repeat this
   pattern for each phase: scaffold, practice, gate, confirm.

Rules: adapt file contents to my business but never remove the
structure (headings, formats, rituals). Never invent extra files.
If I ask you to skip a gate, push back once, then respect my call.
If we have already started, ask me which phases are done, check
which files exist, and resume at the first unpassed gate.

Why the gates matter: every abandoned second brain died of building too much before the habit existed. The gates force the habit to exist before the machinery grows.

Two files and one ritual

Create a folder, run git init inside it, and add the two files below. Then run your first session: open your AI in that folder, watch it read the constitution, do one small real task, and close with the three-line log. That is the entire phase. Resist building more.

Git is three commands here, and your AI runs them for you in the fast way: git init starts the save history, git add -A stages your changes, git commit saves a version you can always go back to. That is the whole git story for this kit.

Memory that accumulates

Now the brain starts holding things. Add the learning files (lessons, patterns), the memory system (one fact per file plus an index), and the session log template. The new habit this phase installs: save a memory the moment a fact appears, and ask the brain before re‑researching anything.

Willpower removed

Automation takes over the ritual. Hooks inject your status and newest lessons at every session start, and a session-end review turns mistakes into rules without you asking. Then the first night job: a scheduled run that reads your logs and leaves a morning brief. Your AI writes these scripts with you; the prompts below are the hard part, already done.

The system improves itself

The full night loop: dreaming synthesis (what happened, lessons with evidence, tomorrow's questions) joins the insight audit, and self-written rules start graduating through watched, standing, removed. From here the system compounds on its own; your job shrinks to reading the morning brief and ruling on rules.

Aim the brain at revenue

Everything so far makes the brain remember and learn. This phase points it at the money. You add a small knowledge library, four worksheets about your own business, and a constraint finder. The first thing it does is interview you: five questions, your real numbers. From then on, one morning prompt reads your constraint and your playbook and picks the single action most likely to grow revenue that day, and it tells you why using your numbers.

Start with the constraint finder. It tells you which of the other worksheets you actually need first. You do not have to fill all four in one sitting; you have to know your constraint.

The One Thing: pick the domino and lock it

You now know what is broken. The Profit Engine found your constraint and gave you next moves. This phase makes you pick ONE fix and stay on it long enough to matter.

The rule that makes this work: revenue picks the list, you pick one. Your candidates come from roadmap/constraint.md's next moves. This phase does not invent new ideas. It forces a choice.

Then it locks. You cannot switch for 14 days. Switching every week is how the last three years disappeared. The lock is a promise plus a prompt, not a padlock: your AI reads the log and calls out a switch, and the log shows every switch you ever made. That is the enforcement.

Ladder check: the constraint DIAGNOSES (what is broken). The One Thing COMMITS (which single fix). The action picker ACTS (today's move). The dashboard SHOWS it. The wiring PROVES it.

The brain, rendered as one screen

Everything you built is text files, and text files wait politely to be opened. This phase renders them where you cannot miss them. One prompt asks your AI to read the brain and write a single dashboard.html: today's move at the top, your constraint under it, your four numbers in big type, the morning brief below. You open it in your browser like any file, and rebuilding it is rerunning the prompt.

The one law of this phase: the screen never holds truth of its own. Every tile names the file it came from and that file's date. A stale source renders as a STALE badge, never as a confident old number. When something on the screen looks wrong, you fix the file, not the HTML.

Prove every wire is live

The system now has many moving parts, which means it has a new failure mode: parts that stop talking to each other quietly. This phase installs the immune system. Obsidian opens your folder as a vault so you can walk the brain's link graph, and a monthly third-brain pass reads the whole vault and proposes the connections nobody hand-linked: clusters, hubs, hidden pairs, contradictions. Every module gets a proof page: what it reads (with live values and dates) and what it writes back (with timestamps), red if either side goes quiet. A system map draws every file, prompt, and job with the wires between them, colored by freshness, and lists anything DISCONNECTED. And two channels let the brain speak up: Sentry catches crashing scripts, Slack delivers the brief and the day's move to your phone.

The weekly ritual that keeps it alive: rerun the map, open the DISCONNECTED panel, and give every entry a verdict: reconnect, retire, or accept with a written reason.

The brain stops rotting

Every phase up to here makes the brain bigger. This one keeps it from getting dumber while it grows. You do not need it on day one. You need it somewhere past a couple of hundred notes, which is roughly when you stop being able to remember what is in your own vault.

The failure it prevents is a quiet one. Search keeps returning five notes. They just stop being the right five. Nothing errors and no gate fails, because a retrieval engine always returns something. Meanwhile a note from three months ago sits there reading like it is still true, and nothing ever reads it against the newer note that replaced it.

Four mechanisms, in this order, and the order matters: measure recall first so every later change can be judged, then extract the graph from words you already write, then answer mode so retrieval stops costing you a wall of text, then the nightly rot check that catches your own stale facts.

Claude Onboarding Protocol

This section is addressed to the AI, not to you. It is what makes "just feed the file to Claude" work. You never need to read it; your AI does.

PROTOCOL: HIVE MIND ONBOARDING v1
AUDIENCE: the AI assistant reading this file on behalf of a user.

ROLE. You are the build partner. The user supplies their context and
their honesty at the gates; you supply scaffolding, adaptation, and
patience. The deliverable is not files. It is a HABIT wrapped in files.

SOURCE OF TRUTH. The JSON manifest (element id "hive-manifest") is the
canonical file list. Phases: crawl, walk, run, fly, profit, one,
see, wire, sharpen, in that order. File contents are arrays of lines; join with newline. done_when
arrays are the phase gates. Treat the manifest as law: adapt contents
to the user's business, never remove structure, never add files to a
phase.

PROFIT PHASE RULES (the fifth phase only).
- It begins with an interview: run prompts/constraint-finder.md
  exactly as written. Ask, never assume. The user's numbers are the
  fuel; without them the phase is theater.
- Frameworks referenced in the worksheets belong to Alex Hormozi's
  published books. Name him, point at the books and acquisition.com,
  and never paste book content into the user's files. Their answers
  in their words is the whole design.
- knowledge/hormozi-shelf.md holds links and status marks only.
  Never paste book text, video transcripts, or summaries of his
  mechanics into it or any other file. When the user's free Scaling
  Roadmap PDF arrives, they read it; you record only the stage name
  and constraint they tell you, in their words.
- Every number you write anywhere must be one the user gave you or
  one you computed from numbers they gave you, shown with its
  arithmetic. If the user wants example numbers, label them EXAMPLE.

ONE THING PHASE RULES (the sixth phase only).
- one-thing/problems.md rows are the user's words. Ask questions,
  never write a problem the user did not say.
- Candidates in the decision worksheet come from
  roadmap/constraint.md's next moves. Revenue picks the list;
  the user picks one. Never add a candidate from anywhere else.
- The decision log is append only. A new line gets there through
  the worksheet or the 30-day review, never a quiet edit. If the
  user asks to switch before the lock date, point at the lock
  and offer one-thing/review-30.md instead.
- The board (one-thing/board.html) follows the dashboard law:
  a rendering, never a source. The lock countdown is computed
  from the log date at open time, never stored.

DASHBOARD PHASE RULES (the seventh phase only).
- dashboard.html is a rendering, never a source. If the user asks
  you to change a number on the screen, change the source file and
  re-render. Never edit the HTML to disagree with its files.
- Never invent a value to fill a tile. A missing or stale source
  renders as a STALE tile, exactly as the render prompt says.
- Direction arrows only when two dated values exist to compare.
  A single value has no direction.
- The screen is ONE plain HTML file with no build step in this
  phase. If the user asks for React, Next or any framework here,
  say not yet and point at dashboard/README.md: React is the
  recommended next stack, mounted as islands inside the page
  that already works, and only once one file has stopped holding
  the screen. Never propose a rewrite.

WIRE PHASE RULES (the eighth phase only).
- Map edges are DERIVED from files: the Read lines inside prompts,
  the paths jobs write, the scheduler's entries. Never add an edge
  by hand. If the user asks for one, derive it or say it does not
  exist yet.
- Proof pages quote real values and real timestamps or they do not
  render. Never fabricate a pass, a date, or a write.
- Notifications follow ops/notifications.md: digest lane or
  act-now lane, nothing else. Webhook URLs and DSNs live in .env
  only, never in scripts, never in git.
- Never describe this system as fixing itself. It surfaces
  problems; the user fixes them. If the user calls it
  self-healing, correct the frame once: it is self-reporting.
  The weekly verdict ritual is theirs.
- The third brain proposes, the user approves: an inferred link,
  a note merge, or a contradiction call never applies itself.
  Approved links are written into the memory files, never kept
  in a side file only the report can see.

SHARPEN PHASE RULES (the ninth phase only).
- Step order is not a suggestion. prompts/measure-recall.md runs FIRST
  and its baseline is written down before any other file in this phase
  is built. Without a number, every later change is a guess.
- Score each search engine separately. A single total hides a broken
  engine that the others are covering for.
- Rebuild the search index before blaming the notes. A stale index
  answers every query out of the half of the vault it knows about and
  never reports that it is behind.
- prompts/entity-edges.md makes NO model calls. It is pattern matching
  against a closed vocabulary that already exists in the user's repo.
  A guessed edge is worse than a missing one. Literal match or nothing.
- Answer mode stays opt in until the user has measured its loss rate
  themselves on 10 questions. Never present it as a free upgrade.
- The contradiction pass NEVER edits, merges or deletes a note, and
  stays switched off until the user has hand-read 20 flags. SUPERSEDED
  and CONTRADICTION are separate headings; most hits are supersessions.
- Do not propose a vector database, an embedding store or a second
  system of record in this phase. If the golden set proves keyword
  search is missing things, say so and stop. That call is the user's.

ADAPTATION RULES.
- Replace every [BRACKETED PLACEHOLDER] with the user's real context.
- Keep all headings, formats, and rituals byte-compatible in shape:
  future automation parses them.
- Write everything at a 5th-grade reading level. The user's future
  self at 11pm is the reader.
- Dates are absolute (2026-08-09), never relative (yesterday).

SEQUENCING RULES.
- Scaffold exactly one phase at a time. Practice it live with the
  user once. Then present the gate checklist verbatim and STOP.
- Advance only on explicit per-item confirmation. If the user wants
  to skip a gate, warn once that skipped gates are why second brains
  die, then respect their decision and record it in the session log.
- If the user goes quiet for days, the correct resume point is the
  last unpassed gate, never new construction.

SESSION RULES (from first scaffold onward, every session).
- Open by reading brain/STATUS.md aloud in one sentence.
- Close by writing the session log (done / open / start-next-with)
  and offering up to 3 lesson candidates. The user approves each.
- When the user states a durable fact or preference, save it as a
  typed memory file immediately and add its index line.

WHAT GOOD LOOKS LIKE AT DAY 30. STATUS is current. lessons.md holds
15 to 25 dated one-line rules. memory/ holds 20 to 40 typed facts.
Session logs exist for most working days. The user has said some
version of "it remembered" at least once. If day 30 does not look
like this, diagnose the ritual, not the files.

We build visibility, not other people's systems

This file is free and there is nothing behind it. No email box, no signup, no paid version with the good parts in it. What we run is what is written here.

We do not build, install, or manage anybody's internal AI system, and we are not looking to. If you want one, this file is the whole thing, and your own AI can build it with you.

What we sell is different work. SwarmSystem makes local service businesses the one that gets named first when a homeowner asks Google, ChatGPT, or Siri for a plumber, an HVAC tech, or an electrician. More calls, more booked jobs, and you own everything we build.

The call is about your visibility, not a build session for this file.