vagor.one — Just a Curious Mind

Nobody writes about the setup. They write about the idea. They write about the launch. They write about the lessons learned six months later when everything is working and they have forgotten how much it hurt to get there.

This is the setup. All of it. Including the parts where I ran the wrong command.

Part 1 — Why Bother

I wanted a record. That is the honest answer. Not a portfolio, not a personal brand, not a content strategy. A record of the things I do, because I do a lot of things and then move on and forget I did them.

I have been accused of having ADHD. I find interest in something, learn it, then move on to the next challenge. It is why I like tech — I can build almost anything. It is why renovations are a pathetic solace at times. The grass always needs touching. It balances things out.

The other reason — I wanted to see what AI could actually do when pointed at a real project with real constraints. I had an idea. I did not have money. I figured, let's see if Claude could be a marketing company.

Turns out it can. Mostly. With a lot of direction.

This document is the backend story. The part before the site looked like anything. The part nobody puts in a tutorial because it is not glamorous and half of it is just fixing mistakes.

Part 2 — What You Actually Need

Before anything else — the inventory.

The Machines

A Mac is the best option for this stack. Unified memory means no VRAM wall for local AI work later. The upgrade path is additive not replacement. My primary machine for this is a MacBook Pro M4 Max with 48GB unified memory.

You do not need that. Any Mac with 16GB or more works fine for the site build. The AI server ambitions come later.

The Accounts You Need

Three accounts. All free to start. All set up with privacy in mind from the beginning.

Proton Mail — proton.me. Free, encrypted, no personal information required. This becomes the email for everything related to this project. Not your personal email. Not your work email. A clean identity.

GitHub — github.com. Create a new account using your Proton email. Give it a username that is not your real name. This account never touches your personal GitHub if you have one. Clean separation from day one.

A domain registrar — I used Porkbun. They include WHOIS privacy free on every domain. GoDaddy charges for it. Use Porkbun.

The Software

Obsidian — obsidian.md. Free. This is where you write everything.
Git — probably already on Mac. Check with git --version in Terminal.
Node.js — needed for Claude Code. Check with node --version.
Claude Code — install with npm install -g @anthropic-ai/claude-code. Requires Claude Pro.
A browser — for GitHub, Porkbun, and checking localhost:3000.

That is genuinely everything.

Part 3 — Setting Up Obsidian the Right Way

Two Vaults — Why

If you already use Obsidian for personal or work notes — stop. Do not add this project to your existing vault.

Create a new one. Separate. Completely isolated.

This new vault connects to Git and GitHub. If your personal vault is in the same place, personal notes end up on GitHub. Even if the repository is private — do not mix them. The discipline of separation saves problems you have not thought of yet.

Your personal vault stays on Obsidian Sync. The project vault does not use Sync at all. Git handles it instead.

Creating the New Vault

Open Obsidian. Bottom left — the vault switcher. Click it. Create new vault. Name it something that matches your project. Mine is vagor-one.

When it asks about syncing — leave it off.

Confirm Sync is off: Settings → Sync → should say "Currently not connected to any remote vault."

The Folder Structure

Inside your new vault create these folders:

workshop/
mind/
frequencies/
curious/
get/
assets/images/
assets/diagrams/
_drafts/

In Terminal:

cd ~/Documents/vagor-one
mkdir -p workshop mind frequencies curious get assets/images assets/diagrams _drafts

Part 4 — Git and GitHub from Scratch

What Git Actually Is

Git tracks changes to files. Every time you save a meaningful change you commit it — a snapshot you can return to. Push that commit to GitHub and you have a remote backup that also triggers your site to rebuild automatically.

Obsidian is where you write. Git is how you save versions. GitHub is the filing cabinet that also runs the printing press.

Confirming Git Is Installed

git --version

If you see a version number you have it. If not:

brew install git

Creating a Privacy-First GitHub Identity

When you commit code to GitHub every commit is tagged with your name and email. If your repository ever becomes public that information is visible to anyone. Set it to something that reveals nothing.

Set your Git identity:

git config --global user.name "your-alias"
git config --global user.email "your@email.com"

Use an alias for the name. Not your real name.

For the email — GitHub provides an anonymous noreply address. Get it from: GitHub → Settings → Emails → Enable Keep my email address private → copy the noreply address.

It looks like: 123456789+yourusername@users.noreply.github.com

Use that. Now commits are tagged with your alias and an anonymous email.

Set it per-repository:

cd ~/Documents/vagor-one
git config user.name "your-alias"
git config user.email "your-noreply@users.noreply.github.com"

Confirm it:

git config --list --local

If you see your real name — fix it before pushing anything.

SSH Keys — What They Are and Why Passwords Are Wrong

Use SSH keys. Always.

A password can be guessed or intercepted. An SSH key is a mathematically linked pair of files — one stays on your machine, one goes to GitHub. They prove identity without transmitting a secret.

Generate your key:

ssh-keygen -t ed25519 -C "your-alias"

Accept the default save location. Use a strong passphrase.

Add to SSH agent:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Display public key:

cat ~/.ssh/id_ed25519.pub

Copy everything from ssh-ed25519 to your alias at the end.

Add to GitHub:

GitHub → Settings → SSH and GPG keys → New SSH key → paste it → title it with the machine name → save.

Test:

ssh -T git@github.com

Type yes when prompted. Should return: Hi yourusername! You've successfully authenticated.

If you use multiple machines — repeat this on each one. Each gets its own key.

Connecting Your Vault to GitHub

Create the repository on GitHub: Click + → New repository → name it → Private → do not initialise with README → Create.

Initialise Git in your vault:

cd ~/Documents/vagor-one
git init

Create .gitignore:

cat > .gitignore << 'EOF'
.obsidian/workspace.json
.obsidian/workspace-mobile.json
.obsidian/sync.json
.obsidian/cache
.DS_Store
.env
.env.local
secrets/
private/
_drafts/
node_modules/
.next/
EOF

Connect to GitHub:

git remote add origin git@github.com:yourusername/your-repo.git

First commit and push:

git add .
git commit -m "init: vault structure"
git push -u origin main

If the push succeeds — you are connected.

Part 5 — Privacy by Design

Privacy is not something you add later. Build it in from the start.

WHOIS Privacy

Every domain registration is publicly searchable — name, address, email, phone number. Unless you use WHOIS privacy.

Porkbun enables it by default. Check it is on: Domain Management → find your domain → look for a glasses icon → it should be green.

What Your Domain Registration Still Reveals

Even with WHOIS privacy on, your registrar has your real contact information internally. Use your Proton email as the account email. Get a PO Box or virtual mailbox address for the physical address field. Do not use your home address.

The Proton email change is the most urgent. Do it before you forget.

Anonymous Commits

Check your commits are clean before pushing:

git log --format="%an %ae %s" -1

Should show your alias and noreply address. If it shows real information:

git commit --amend --reset-author --no-edit

Part 6 — Claude Code — The Actual Build

What Claude Code Is

Claude Code writes, edits, and manages code through conversation. You describe what you want. It does it. You look at the result. You describe what needs changing. It changes it.

It requires direction. Vague instructions produce vague results. Precise instructions produce precise results.

In Claude Desktop — look for the Code tab alongside Chat and Cowork.

The First Instruction

Point Claude Code at your project folder. Then:

I am building a personal brand website called [name].
Please create a Next.js 14 project with App Router,
Tailwind CSS, Framer Motion, and TypeScript.
The site has five content areas: Workshop, Mind,
Frequencies, Curious, and Get.
Content comes from markdown files in folders that
already exist. Do not overwrite existing folders.
Start by scaffolding the project and confirm when ready.

From there — iterate. Look at what it built. Describe what is wrong. It fixes it.

Why Screenshots Changed Everything

The biggest unlock — screenshot the browser and paste it into Claude Chat. Not Claude Code. Claude Chat.

Describe what you see and what you want changed. Claude Chat writes the exact instruction. Paste that into Claude Code. It executes.

This loop is how the site went from skeleton to something real. The logo replacing the O in .one looked nothing like what it is now. Each version was a screenshot, a description, an instruction, an execution.

What Claude Code Cannot Do

It cannot remember. Every session starts fresh. Re-orient it at the start of each session:

I am continuing work on [project]. Please read the
existing codebase in this directory and confirm what
has been built before we continue.

It reads the code and picks up where it left off. The code is the memory.

Part 7 — What Broke and How I Fixed It

The section no tutorial includes.

npm audit fix --force

Do not run this without understanding what it does.

npm audit fix is safe. npm audit fix --force is not — it installs whatever version fixes the vulnerability even if incompatible with everything else. It downgraded Next.js from version 14 to version 9. That broke everything.

The fix:

git checkout -- package.json package-lock.json
rm -rf node_modules
npm install

Git saved it. This is why you commit before doing anything experimental.

The vulnerability it was trying to fix was a PostCSS issue that Next.js 14 handles internally. The audit tool flagged it incorrectly. The correct response was to ignore it.

Running npm from the Wrong Directory

Error:

npm error code ENOENT
npm error Could not read package.json

Translation: wrong folder.

Fix:

cd ~/Documents/your-project-name
pwd

pwd tells you exactly where you are. If it is not your project folder — navigate there. Always confirm your location before running npm commands.

SSH Keys on Multiple Machines

Each machine needs its own SSH key generated and added to GitHub.

Signs of this problem:

Permission denied (publickey)
fatal: could not read from remote repository

Fix — on the failing machine:

ls ~/.ssh

If nothing is there — generate a key, add it to the agent, add the public key to GitHub, test, push again. Covered in Part 4.

GitHub Username Already Taken

Both vagor and vag0r were taken. Domain investors get there first.

Solution — add something to make it unique. Do not compromise on the domain. Compromise on the GitHub username. Most visitors never see it.

npm approve-scripts Error

When installing Claude Code:

npm error code ENOMATCH
npm error No installed packages match

Fix:

npm uninstall -g @anthropic-ai/claude-code
npm install -g @anthropic-ai/claude-code --foreground-scripts
claude --version

If you see a version number — installed. The warning is noise.

Part 8 — The Stack in Plain Terms

You write in Obsidian. Markdown files. Plain text.

Git tracks every change locally.

GitHub holds a private remote copy. Push triggers a site rebuild.

Next.js reads your markdown files and converts them into web pages. Tailwind styles them. Framer Motion animates the carousel.

Vercel deploys to the live web. One command the first time. Automatic after that.

Claude writes content in your voice. Grok manages and publishes with minimal token cost.

The Mac Studio arrives in October and takes over hosting. Zero cloud cost beyond electricity.

That is the whole thing.

Part 9 — What Is Next

The site runs locally. The pipeline works. The first post is live.

Next steps in roughly the right order:

Get a PO Box. Update the domain registration address. Close the last privacy gap.

Connect the domain to Vercel. Currently vagor.one goes nowhere. One DNS record changes that.

Write the next post. The first couple document the build. The third document will be something else entirely. An empty site with a beautiful hero is still an empty site.

Set up the Mac Studio in October. Ollama, Open WebUI, a 70B model on the local network. The team brain. The research machine.

One step at a time. That is how everything gets built.

If something did not work the way I described — that is genuinely useful feedback. The comments are open.

Built by hand. Powered by curiosity. Occasionally broken by npm.

vagor.one — Shaped by water. Built by hand. Powered by curiosity.

Built from Scratch — The Backend Nobody Talks About