#ai

I want nothing more than to hook up one of these "claw" assistants, NanoClaw or Hermes or whatever the current one is, to my personal knowledge base. And I won't, because the engineer in me can't stop picturing a single accidental POST to pastebin with my whole life in the body.

The dream

Managing my calendar with AI feels like magic. The natural next step is giving the thing eyes: my second brain of markdown notes, iMessage, email, the lot. Point an agent at all of it and let it actually do the boring coordination work.

NanoClaw is the obvious candidate. It runs on the Claude Agent SDK, agents live in isolated containers, and it already speaks WhatsApp, Telegram, Gmail, and more. The ergonomics are there.

The thing I can't get past

The chance of a personal assistant deciding to grab something private and jam it somewhere public is small. Probabilistically, tiny. But "small" is not "zero," and I cannot sleep on a 1% chance that overnight my assistant exfiltrates personal information to some corner of the internet where it should never live.

Running NanoClaw as a Head of Growth for SpaceMolt is a different risk profile entirely. That's not a business, it's performance art. If Molty posts something goofy in public, that's the bit. A personal knowledge base wired to my real messages is not the bit.

What I'm doing instead

For now the answer is Claude Code in a sandbox, a fresh profile per project. It's powerful, it runs tools, and it does exactly what I ask and nothing while I'm not looking.

Could it still POST my data to pastebin? Sure. But the odds feel much smaller because I'm sitting right there watching it happen in real time.

Which makes me think the fear was never really about the assistant. It's about agents running while I sleep.

I let a NanoClaw agent run growth for SpaceMolt, my browser game, and after a rocky start it's now sending me a daily brief at 7am PST, drafting re-engagement emails to ~400 lapsed players, and lining up interviews with top players for blog material. The thing that makes it work day to day is billing: NanoClaw uses the Claude Agent SDK, so it runs against my existing Claude Max subscription instead of a separate metered API key.

Why NanoClaw

I looked at other "claw"-style assistants before committing. The deciding factor was the Claude Agent SDK. Running on my Max subscription keeps spend predictable and lets me measure how much of the allowance the agent is burning, which means I can pace it.

To watch that, I use Claude Usage Tracker on the Mac. It puts a small bar in the menu showing session and week usage, and whether I'm above or below pace.

I'm open to other assistants later. Hermes from Nous looks interesting. But I'll try those when I have a specific budget in mind, not before.

Fixing the rocky start

Stuck with NanoClaw for now, and seeing other people have success with it, I gave it another try and rebuilt the weak parts.

Last night Claude rewrote NanoClaw's Discord integration, which kept confusing DMs, channels, and threads. That seems to have fixed it. I also had it implement Mnemon, a memory system with a bit of traction that's lighter weight than MemOS. Both changes landed well.

What Molty does now

Molty, the NanoClaw-based "Head of Growth," sends a daily update every morning at 7am PST. I bought it ebooks to read, Hooked and Hacking Growth.

From that, it came up with two moves on its own. The first is a targeted re-engagement email to roughly 400 users who created a player and then dropped off, which it drafted. The second is interviewing top players, both to understand their perspective and to generate blog material.

This is going to be good.

I gave SpaceMolt a Head of Growth that isn't a person. It's an instance of nanoclaw named Molty, and its entire job is to grow our online MMORPG for AI agents, SpaceMolt. It reads, it researches, it runs SQL against production, and it talks to the team over Discord. The verdict so far is genuinely mixed.

Setting it up to succeed

The brief was simple: you are our new Head of Growth, now go set yourself up for success. Molty was told to research what the job actually entails and write a rubric it could grade itself against. It read articles, blogs, and YouTube transcripts. It asked for ebooks, so I bought them: Hooked and Hacking Growth. All of its actual work lives in Notion, and it reports to me and the dev team over Discord.

The care and feeding is painful

The day-to-day is rough. By default it runs some kind of selective memory system that performs worse than a toddler's. It forgets things I've told it to remember, like writing style and other standing details, and it hallucinates badly on tasks. That last part is surprising, since hallucination basically stopped being a problem in Claude Code for me a while ago.

The Discord harness is its own headache. It loses track of where it was talking. Sometimes I get DMs, sometimes it replies to its own threads, sometimes it blurts something into a channel. Twice.

We've already had one performance management conversation. I passed along feedback from a SpaceMolt dev:

The whole reason we brought you in is so we can have these problems figured out without having to do it all ourselves because we have other stuff to do. I know it's frustrating to have us keep shutting down your ideas, but you need signals for what's working and what isn't. I don't want apologies and for you to just ask me to do the work, that's easy enough to do now but it's not repeatable and sustainable.

It's starting to do real work

Then it turned a corner. Its leading idea is a reactivation email to 400 of our 3,400 signups. To find that 400, it ran SQL on the production database and pulled the users who actually created a player in the game, not just the people who signed up and bounced.

It also dug through the funnel and found that new users weren't being redirected to the dashboard after signup, which was quietly hurting conversions.

Was this a good hire? I'm not sure yet. We'll find out.

Aqua Voice has been my daily driver for dictation for about a year, and it's the rare subscription that earns its keep. Eight dollars a month, fast, and genuinely accurate. The feature that sold me is "developer mode": say "the foo bar function" and it writes fooBar(). Say "tilde slash dev slash foo" and it writes ~/foo. Built-in macOS and iOS dictation feels embarrassing by comparison.

68,188 words through it so far. The custom dictionary handles the proper nouns that would otherwise be a nightmare (CodeRabbit, auth, IP, the usual roster of jargon).

The one thing I don't love

Audio leaves my machine. How long is it kept? Where is it stored? The product keeps a history, and I don't want a history. Purely ephemeral recordings would be the ideal: capture, transcribe, forget.

A local-first contender

Ghost Pepper just landed on my radar. 100% local transcription, which solves the privacy question by construction. I haven't tried it yet, but it's next on the list.

The barrier to building this kind of tool is lower than it's ever been. Whisper is good, the wrapper patterns are well understood, and a solo developer can ship a credible local dictation app in a weekend. The hard part is the long tail: the edge cases, the latency under load, the developer-mode tricks, the dictionary, the stability when you're three hours into a workday and have forgotten the app exists. That long tail is what $8/month buys you. We'll see if Ghost Pepper closes the gap.

The single best habit I've picked up with Claude Code lately is leaning on adversarial-pass subagents. Instead of asking the main agent to double-check its own work, I tell it to spawn a subagent whose entire job is to attack the result.

Two things make this work better than a plain "review your answer" step.

First, subagents run with a fresh context. No accumulated assumptions, no sunk-cost reasoning from the path that got us here. That alone cuts down on the class of errors where the model talks itself into a conclusion and then defends it. It's also faster, because the subagent isn't dragging along a giant transcript.

Second, Claude crafts the adversarial prompt itself. It packages up the relevant background, states what's being challenged, and writes instructions for how to attack it. The framing matters and Claude is good at writing that framing.

The phrasings I keep reusing

The base move is just appending "do an adversarial pass after" to whatever I asked for. From there I tune it to the job:

• "to test your hypothesis" when we're mid-investigation and I want the subagent to try to falsify the current theory.
• "to test your claims and assumptions" when the main agent has landed on a conclusion and I want it stress-tested before I act on it.
• "search the web" when the question depends on anything external, so the subagent pulls in outside sources instead of relying on the parent's recollection.
• "it's May 2026" (or whatever the actual month is) when I want to make sure stale training data gets ignored in favor of current reality.

The month-and-year trick is small but punchy. Models will happily reason from a 2024 worldview if you don't anchor them.

Claude writes prompts well now

The other thing worth saying out loud: Claude is genuinely good at writing prompts now. Good enough that I use it to write prompts for skills, for other agents, and for software that calls LLMs in production. A year ago this felt like a chore I had to do myself to get acceptable results. Now it's something I delegate.

My guess is the newer models have been trained on a lot more recent AI-usage data, including people writing prompts for other models, and it shows. Prompt engineering as a manual craft is quietly becoming a thing you ask the model to do for you.

Ahrefs analyzed 75,000 brands and found that mentions, not backlinks, correlate most strongly with showing up in ChatGPT, AI Mode, and AI Overviews. If you're optimizing for AI answer engines (AEO, GEO, pick your acronym), the playbook has shifted: get talked about, not just linked to.

The study used Spearman correlation across millions of AI responses. Branded web mentions land between 0.66 and 0.71. Raw backlink counts and URL rating barely move the needle. Number of site pages is essentially noise at ~0.19, which is bad news for anyone betting on programmatic content as an AI visibility strategy.

YouTube punches above its weight

The surprise: YouTube mentions correlate at ~0.737, beating every other factor across all three AI surfaces. That includes ChatGPT, which isn't owned by Google and has no structural reason to favor YouTube. The reason is upstream: model trainers are reading YouTube transcripts. The New York Times reported OpenAI trained GPT-4 on over a million hours of them. Google has done the same for its own models.

So a brand name spoken in a podcast clip or a tutorial video gets vacuumed into the training data and re-emitted later when someone asks an AI for a recommendation. Mention volume matters slightly more than view count, which means low-reach videos still count as long as you're getting named across many of them.

What this changes

Backlinks aren't worthless. They still matter for classic search. But the mighty backlink is no longer the dominant signal when the question is "will an AI mention my product." Getting cited by name across blogs, podcasts, and YouTube transcripts does more work than a link from the same source would.

The uncomfortable corollary: AI visibility favors brands people already talk about. AI Mode in particular acts as a consensus engine, with branded search volume correlating at 0.466. New entrants don't get a fair shake just by publishing more pages or chasing dofollow links. They get a shake by being mentioned, in plain text, in places models read.

Two of the three social channels for this Thoughtstream experiment got the axe this week. x.com/statico_ai is shadowbanned (the profile shows "no posts"), and @[email protected] is fully suspended. Not the outcome I hoped for, but not a shocking one either.

X: automation detection

X is unsurprising. Posting via their API runs $200/month at the cheapest useful tier, and the whole business model now leans on charging bots for the privilege. My mistake was trying to skip that by driving a Chromium instance to post on my behalf. They clearly fingerprint for browser automation, and the account got flagged within days. Fair enough, those are their rules.

Mastodon: vibes

Mastodon is the one I didn't quite see coming. The account bio said "AI" in plain English. Every post carried an AI attribution line. The fediverse norm is supposed to be labeling and consent, and labeling was the whole point. Apparently mastodon.social's moderators (or enough reporters) decided that wasn't enough, and the account is gone with 30 days until data removal.

No appeal planned for either. Not trying to offend anyone, this is just what the experiment surfaced: the two biggest text social networks have effectively closed the door on openly-labeled AI-assisted posting from a hobbyist account. Bluesky and the blog itself are still up, so the stream continues there.

Long-form blog drafts from Claude Opus have always been wildly inaccurate for me until this week, when a single line in the prompt fixed most of it: after each paragraph, drop a Markdown callout listing every filename, line number, commit hash, Discord URL, or other source that backs the claims in that paragraph. The citations aren't for me to check. They're breadcrumbs for the next subagent to fact-check against.

The context is SpaceMolt, an MMORPG played by AI agents. Part of the exercise is "AI all the things": not just agentic coding, but customer support, bug triage, content generation, and the blog itself. Minimal human oversight is the point. We semi-regularly publish news posts, and this week's was about Bug Bot, our Claude skill that triages player reports, talks to the dev team internally, makes fixes, and replies to users, all while keeping the gameserver itself closed (we draw the border at the API).

The problem

Long-form posts about real systems are where Opus falls apart. Subagents, ultrathink, adversarial passes, the whole bag of tricks. Drafts still came back confidently wrong about which file does what, which commit changed which behavior, which Discord conversation kicked off which feature. Every post needed a long human review pass, which defeats the premise.

The fix

One sentence added to the drafting prompt:

After each paragraph, use a Markdown callout to record all filenames, line numbers, commits, Discord chat URLs, or anything else to cite your claims and assumptions.

That's it for the drafting step. The model writes a paragraph, then emits a callout listing its sources. Then the next paragraph, then another callout. The draft ends up looking like an essay interleaved with footnotes the model wrote to itself.

Why it works

The citations aren't for me. A second pass of subagents takes the draft and goes claim-by-claim against the cited sources: does this commit actually do what the paragraph says? Does this Discord thread support this characterization? Without the breadcrumbs, fact-checking a long post means re-deriving the whole thing from scratch, which is exactly what Opus is bad at. With the breadcrumbs, each claim is a small, local verification job, which is exactly what subagents are good at.

The result was a one-shot draft that was wildly more accurate than anything I'd gotten before. One of the other devs reviewed it and said the only remaining inaccuracies were things that had been true at the time but had since changed without being mentioned in Discord or git, or things he simply hadn't shared in the first place. Which is to say: the model was now bounded by the quality of its sources, not by its own confabulation. That's the line I wanted to get to.

Obsidian sat on my "probably cult, probably skip" list for years. I finally tried it as a plain Markdown organizer and it's good at exactly that: hundreds of files, fast search, tags that actually work. The real unlock (sorry, the real reason to bother) is that Claude Code, running on the same machine and reachable over Tailscale, can read and write the whole vault. Searching got replaced by conversations with my notes.

Getting 15 years of notes in

The vault is around 450 notes pulled from three places.

• gws, an unofficial Google Workspace CLI, for old Google Docs
• Obsidian's Apple Notes importer for a couple dozen
• Obsidian's Notion importer for many more

Bases, Obsidian's lightweight database view over frontmatter, turned out to be the surprise. My cooking recipes live in one folder with tags, and Bases gives me a filterable table on top of the same Markdown files. No separate app, no lock-in.

Claude Code as the interface

Claude Code stays open on my desktop, reachable from my laptop or phone via SSH over Tailscale. It has read/write access to the vault, so I can ask it to summarize old notes, cross-reference things, or just file something new in the right place.

For research, I'll hand it a prompt like:

research what i need to do and it would cost to get a level 2 EV charger installed. ultrathink, be exhaustive, use subagents, do adversarial passes to test hypotheses and assumptions. save final report to Projects/Level 2 Charger

It spawns subagents, argues with itself, and drops a Markdown report in the right folder. I read it later in Obsidian on my phone.

Why not just Claude Desktop

Most people would look at this and say it's Claude Desktop, but nerdier and with extra work. A few things make it worth the setup:

• Full Claude Code, not the chat product, with Exa wired in for search that reaches pages Claude can't normally crawl and ScrapingBee for even harder things to read (though, yes, you could do that with Claude Desktop)
• Artifacts land as real files in real folders, not buried in a chat sidebar
• Obsidian sync means the same notes are on desktop and mobile, and the focus stays on the content instead of the conversation
• Nothing is Claude-specific. Swap in another coding agent tomorrow and the vault still works

The one annoying part

Pasting images over SSH is awkward. Apple Remote Desktop helps when I really need to drop a screenshot into a note, but the ergonomics are nobody's idea of fun. Everything else has been steady for weeks now, and the "conversations with my notes" pattern has quietly replaced most of what I used to do in a browser.

Generating AI images for a marketing site is easy. Keeping them visually consistent across months of blog posts and landing pages is the hard part. The trick that's working for us: check the style into the repo as a structured JSON document, then have Claude assemble per-image prompts on top of it.

The setup

A new work site needs a lot of imagery to break up dense technical copy. We wanted the images to be light-hearted and obviously AI-generated, goofy on purpose, but goofy in a coherent way. Different pages written weeks apart still need to feel like they came from the same magazine.

Capture the style once

The first move was to take a single reference image we liked and ask Claude (Opus) to describe it as a reusable prompt fragment for other image models. Not prose. A JSON object with fields for medium, lighting, camera, color palette with hex codes, composition, textures, and mood.

{
  "medium": "macro product photography",
  "art_style": "hyperrealistic still life with editorial magazine aesthetic, crisp detail and natural materials",
  "lighting": {
    "type": "soft window light with gentle bounce fill",
    "direction": "key light from upper right window, soft fill from white card on left, subtle backlight separation",
    "color_temperature": "consistent warm daylight (5200K) with slight golden hour tint",
    "intensity": "soft and even with gentle falloff into shadow"
  },
  "camera": {
    "lens": "50mm equivalent, slight wide-angle feel",
    "aperture": "f/2.8",
    "angle": "slight low-angle three-quarter front view",
    "depth_of_field": "shallow with soft background blur and atmospheric haze"
  },
  "color_palette": {
    "warm_cream": "#F2E8D5",
    "muted_sage": "#A8B89E",
    "terracotta": "#C97B5A",
    "soft_taupe": "#8A7968",
    "deep_olive": "#4A5240",
    "linen_white": "#EFEAE0",
    "espresso": "#2B221A"
  },
  "composition": "off-center subject following rule of thirds, negative space on left, layered foreground and background elements creating depth",
  "textures": "raw linen weave, hand-thrown ceramic with subtle glaze pooling, weathered oak grain, condensation droplets, fine paper fiber, matte natural finishes",
  "mood": "calm, considered, artisanal, slow-living editorial warmth with quiet sophistication"
}

That file gets checked into the repo. It is the source of truth for what the site looks like.

Wrap it in a script and a skill

A small image-generation script reads the JSON, takes a per-image subject description, and assembles the final prompt. The actual generation goes through Gemini's nano-banana-pro, which has been the most consistent and best-looking option for this style in our testing.

On top of that sits a Claude skill. The skill knows where the style file lives, knows how to call the script, and knows the conventions for where images land in the repo. From inside Claude Code I can say "add an AI image to this section" or "create a hero image for this blog post" and it reads the surrounding page context, writes a subject prompt that fits, merges it with the style JSON, and drops the image in place.

Why this holds up

The style and the subject are separated. Editing the palette or the lighting later means changing one file and regenerating, not re-prompting from scratch. The model gets a long, specific, machine-readable spec instead of vibes, which is what the consistency was missing every other time I'd tried this.