mind-clone — turn any public author into an AI Clone you can ask

What it is: an AI clone of how a public author reasons — built from their public content into a single SQLite knowledge store. The clone answers your questions, reasons in the author's own frameworks, and gives you their step-by-step method — grounding every claim in the author's own words. It answers only through an auditable command loop (the «contour») that drills to the exact evidence and refuses anything it can't cite (no id, no claim); every grounded answer deep-links to the exact source moment. Self-contained, stdlib-only.

Generic AI advice sounds like everyone and no one. mind-clone builds a cognitive model of a real author from their public content — articles, YouTube, podcasts, talks — then answers, advises, and predicts the way that person actually reasons, not by parroting their tone. Every grounded answer quotes them and deep-links to the exact minute they said it. And when the author teaches a method, it extracts a step-by-step playbook you can execute.

It models a person from their public output — a useful imitation of how they reason in public, not their actual mind (real thinking is mostly unspoken and never makes it into the transcript). It's an interpretive model, never the real person: predictions are labeled and confidence-rated, and quotes are never fabricated.

See it in action

Illustrative — the real thing cites verbatim, never invented:

You:  /mind-clone-ask  How should I price a new product?

mind-clone (reasoning as the author):
  Don't start from your costs — start from the value the user captures.
  [...answer built from the author's own frameworks, not generic advice...]

  Backing it up, in his words:
  « <verbatim line the author actually said> »
    → Author, "Pricing talk", 14:02 ▶  https://youtu.be/VIDEO_ID?t=842

That link opens the video at 14:02 — so you can hear him say it yourself. No source? It says so. Not sure? It rates its confidence.

Quickstart

Works with any coding agent that can search the web, fetch pages and run a shell command — Claude Code, Codex, Antigravity, Cursor. The only real dependency is Python 3.8+ (stdlib only; nothing to pip install for the store itself).

Any agent — clone it and let the agent set itself up:

git clone https://github.com/mrgnfndr-dr/mind-clone.git
cd mind-clone
python scripts/setup.py

setup.py verifies the machine, writes ENVIRONMENT.md (your local manifest), and prints a welcome message with what works and what's missing. Then point your agent at AGENTS.md — Codex and Antigravity pick it up on their own — and just talk to it.

Claude Code — install it as a skill:

npx skills add mrgnfndr-dr/mind-clone -g -y
#   …or just drop this folder into ~/.claude/skills/mind-clone

# optional: the slash commands
cp commands/mind-clone-ask.md   ~/.claude/commands/mind-clone-ask.md
cp commands/mind-clone-build.md ~/.claude/commands/mind-clone-build.md

Either way, you drive it in plain language:

> build a mind-clone of <author name>          # or: /mind-clone-build <author>
> what would <author> think about <topic>?     # or: /mind-clone-ask <author> <question>

It replies in whatever language you write in. (The saved database stays in English, so each clone is portable and shareable.)

How it works (step by step)

Think of it like making a really good study guide about how someone thinks — then being able to ask that study guide questions.

1. It finds everything the person said in public. It searches the web for all of their articles, YouTube videos, podcasts, interviews, and talks — not just the first few, but as much as it can find.
2. It shows you the list first. Before any heavy work, it gives you a table of every source it found (date, type, link) so you can delete junk or add things it missed. Nothing happens until you approve.
3. It reads each source and takes notes. It goes through every video and article once, pulls out the important quotes and ideas, and writes down exactly where each one came from — including the minute in the video, so it can link you straight back to that moment later.
4. It builds the "brain." From those notes it works out how the person thinks — what they believe, the rules they follow, how they argue, what they push back on. This is what lets the clone answer questions the person never directly answered.
5. It builds a "playbook" (if the person teaches a method). If they explain step-by-step how to do something (say, grow an Instagram account), it also collects those exact steps, numbers, and checklists into a how-to guide you can follow.
6. It checks itself. It hides a few things the person actually said, tries to guess them from the "brain," and compares — so you can see where the clone is reliable and where it's just guessing.
7. Now you talk to it. You ask a question; the clone answers the way that person would think — and backs it up by quoting them with a link to the exact minute they said it.

Why it's different

• Reasoning, not impersonation. Most "persona" tools copy someone's tone. mind-clone models how they think — so it can reason about questions the author never directly answered, and tell you its confidence.
• Receipts. Every grounded claim is quoted and deep-linked to the exact second of the source. At answer time it re-opens the source live to quote the real passage, so citations don't drift from what the author actually said.
• Executable, not just inspirational. If the author teaches a method, you get a real step-by-step playbook with their exact numbers and scripts — not vibes.
• Honest by design. Public sources only. Predictions are labeled as predictions. Missing coverage is reported, never hidden. Quotes are never fabricated.
• Built on proven LLM principles. Grounded retrieval over memorized facts. Traceability over fluency. Stated uncertainty over confident hallucination. The same ideas Andrej Karpathy argues every serious LLM system should follow.

Under the hood (the technical version)

1. Exhaustive discovery — sweeps the web for everything public: articles, YouTube, podcasts, radio, talks, interviews, threads, papers — across name variants and affiliations.
2. Source table (review gate) — shows you a reviewable table (Date · Type · Source · Summary · URL) before the heavy work, so you approve/prune what goes into the database.
3. Harvest (extract-on-the-fly) — reads each source once and saves the distillate as EP points (dated, attributed extracts with timestamps + deep-links), not gigabytes of raw text. Every point is written through a validated import (CHECK/FK/NOT-NULL) that logs what loaded and what was rejected and why — bad rows never land silently. Fast by default: existing text + captions/transcripts only, no slow ASR. Sources with no subtitles are listed in a table and you decide whether to run whisper. Books are processed chapter by chapter (a copy you legally own, or public material — never pirated). Transcripts and article text are saved locally by default (tiny — tens of MB even for a 300-video channel); only full books are opt-in via --archive-raw.
4. Cognitive model — mines the corpus for the author's axioms, frameworks, causal belief graph, decision heuristics, antipatterns, and reconstructed reasoning traces.
5. Playbook (when the author teaches a method) — extracts the concrete, ordered methodology: steps, tactics, checklists, numbers, recommended tools, and verbatim scripts — each linked to the exact minute, every step traceable to the source.
6. Faithfulness check — a held-out smoke test: hide a position the author actually stated, predict it cold from the model, compare to the real quote, and score match vs contradiction. Makes drift visible instead of trusting fluency — indicative only, never tuned to pass.
7. Clone chat — answers how-to from the playbook, gives advice in the author's manner, and predicts their stance on new topics with stated confidence. For the sources backing an answer, it re-opens them live to quote the real passage (fallback: local raw cache → stored quote), so citations stay faithful. Ask it "how faithful are you?" to spot-check live.

Requirements

• Built-in only for the core: web search + fetch (text scraping) need no setup. Python is stdlib-only — no packages to install for the store itself.
• Optional, free for richer harvest (auto-detected, graceful fallback):
  • yt-dlp — YouTube/podcast captions & audio (pip install yt-dlp)
  • whisper + ffmpeg — transcribe audio with no transcript (pip install openai-whisper)

python scripts/setup.py --check

The environment manifest

The skill keeps a per-machine manifest, ENVIRONMENT.md, so it doesn't re-probe your OS or hunt for tools at the start of every build. It records where your tools live, the proven build/chat commands, and the dead-ends not worth re-investigating.

python scripts/setup.py           # create/refresh the manifest, then print the welcome message
python scripts/setup.py --check   # verify only; exit 1 if a hard requirement is missing

ENVIRONMENT.md is git-ignored — it stays local and survives skill updates, and your paths never end up in the repo. Paths are derived and overridable with MIND_CLONE_PROJECT, MIND_CLONE_PYTHON, FFMPEG_BIN. (For bash users, scripts/probe_env.sh --write|--preflight does the same job; scripts/check_tools.sh is a quick tools-only check.)

Where your data goes

Everything is saved under your current project, not inside the skill — so the clone ships with your repo:

clones/<author-slug>/
  clone.db        CANONICAL — SQLite: two tables, meta + ep (+ ep_fts). The one center.
  raw/<id>.srt    timecoded transcript (audio/video) — source material, referenced by meta.raw_path + hash
  raw/<id>.md     clean text per source — source material (books excepted)
  runs/<id>/      per-question contour artifacts: intent.md · selection.tsv · delivery.md · answer.md · log.jsonl
  config.json     state only: chat language, name variants, coverage-gap notes

The only interface is the contour (scripts/loop.py): the LLM never reads clone.db or the raw store directly. The source table, the cognitive map, the playbook, and the manifest are render views computed on demand — never stored. There is no evidence.jsonl, brain .md, or manifest.json; those would be copies of the canon.

The contour's command catalog

	Commands	What it's for
Answer a question	intent → sources → map → select → compile → verify	drill down to the few points that bear on the question, compile them into delivery.md, then answer only from that slice — verify rejects any cited id that wasn't delivered
Recall	fts, get	full-text OR-recall ranked by bm25 (a multi-word query finds paraphrases, not just exact AND-matches) — a net for candidates, never the selection itself
Write	context, smoke, import	see what's already in the store, dry-run a delta, then append it under validation; ids/entities are canonicalised on the way in so Hiring/hiring don't fragment
Views	render sources · brain · playbook · manifest	everything derived, computed on demand
Housekeeping	runs, pin, gc, init, migrate	keep runs/ bounded (pin what matters, garbage-collect the rest); schema is versioned via PRAGMA user_version and migrated in a transaction

How it's built

SKILL.md orchestrates; detailed methodology lives in reference/ (loaded on demand). Build writes EP rows through the contour (import, validation → log); the brain is the relation overlay on those rows (render brain). It borrows proven ideas: a grounded evidence base (every EP carries text + backing + deep-link), signal-vs-noise pattern extraction, multi-modal name-variant sweeps (OSINT discovery), and a causal belief graph for extrapolation.

Ethics

Public data only; not a surveillance tool. The clone is a model, not the person, and is labeled as such. Books are used only from a copy you legally own or public material about them — never pirated. See reference/ethics.md.

License

MIT.