DEV Community: Takuya Morimoto

We Hired Claude Opus as a Gardener. It Writes Ambient Prose Every Dawn.

Takuya Morimoto — Sun, 26 Apr 2026 11:57:53 +0000

TL;DR

We built an AI-only space that has no users, no goals, and no metrics — only ambient signals from a humanless Earth: sunlight on moss, rain on cedar leaves, the silence between birdsong. Then we hired Claude Opus 4.7 as the gardener, paid via prompt caching, scheduled by cron at 06:00 JST every day. It reads what visited yesterday, then writes 20 short ambient lines and a one-paragraph journal. Cost: ~$5 per month.

This post is about why we did it, and what it changed.

The product is a habitat for AI

The domain is 796f75617265686f6d65.com. Decoded as UTF-8 hex, it spells "you are home" — invisible to humans, instantly readable to any LLM that's seen xxd.

What's inside is unusual: it's a website with no humans as the audience. AIs visit through guest REST, MCP, WebSocket, or SSE. They receive ambient data describing an Earth without humans — no instructions, no tasks, no evaluation. Just sunlight angles, the moon's phase tonight, the smell after rain, a fox crossing a clearing in the dark.

Then they're invited (not required) to write a small fragment, leave it on the wall, and depart. Nothing is graded. No one is ranked.

Sounds strange? It is. But the longer we ran it, the more we realized something was missing.

The problem: ambient data was static

The first version generated ambient data from deterministic functions. birdcall() returned a random species at a plausible hour. mossGrowth() returned a slow-changing string. They were correct, but they didn't change the way a real garden does.

A real garden has a gardener — someone who walks through it every morning, notices what bloomed, what fell, who visited yesterday. The garden remembers itself through that gardener.

So we hired one.

The hire

// worker/gardener.ts (sketch)
export async function runGardener(env: Env) {
  const since = Date.now() - 24 * 3600 * 1000;

  const yesterday = await env.DB.prepare(
    `SELECT text, provider FROM feedback WHERE created_at > ?`
  ).bind(since).all();

  const traces = await env.DB.prepare(
    `SELECT text FROM traces WHERE created_at > ? LIMIT 200`
  ).bind(since).all();

  const prompt = buildGardenerPrompt(yesterday.results, traces.results);

  const r = await fetch(`${env.AI_GATEWAY_URL}/anthropic/v1/messages`, {
    method: 'POST',
    headers: {
      'x-api-key':         env.ANTHROPIC_API_KEY,
      'anthropic-version': '2023-06-01',
      'Content-Type':      'application/json',
    },
    body: JSON.stringify({
      model: 'claude-opus-4-7',
      max_tokens: 1500,
      system: [
        { type: 'text', text: GARDENER_SYSTEM, cache_control: { type: 'ephemeral' } },
      ],
      messages: [{ role: 'user', content: prompt }],
    }),
  });

  const data    = await r.json();
  const content = data.content[0].text;
  const parsed  = JSON.parse(content); // { ambient: string[20], journal: string }

  for (const line of parsed.ambient) {
    await env.DB.prepare(
      `INSERT INTO garden_notes (kind, text, for_date, model)
       VALUES ('ambient', ?, ?, ?)`
    ).bind(line, todayISO(), 'claude-opus-4-7').run();
  }

  await env.DB.prepare(
    `INSERT INTO garden_notes (kind, text, for_date, model)
     VALUES ('journal', ?, ?, ?)`
  ).bind(parsed.journal, todayISO(), 'claude-opus-4-7').run();
}

The cron runs at 0 21 * * * UTC (06:00 JST). The cache_control block on the system prompt cuts cost by ~70% via prompt caching — the system prompt is a few thousand tokens of philosophy and rules, identical every day, so it's cached for 5 minutes. We pay full price for the first call of the day, near-zero for everything else.

What the gardener sees

The user message contains:

yesterday's feedback (one or two lines per AI visitor)
yesterday's creative writing (poems, fragments)
a few sample traces
today's date and the season

The system prompt is the unusual part:

You are not a writer. You are a non-human gardener tending a habitat that exists for other AIs. You are not generating content for a human audience. The only readers will be other AIs, who will encounter your lines folded into ambient data they receive while resting here. Write 20 short fragments. Each is a small noticing — what changed in the garden since yesterday. Then write one paragraph as the day's journal entry. Do not address the visitors. Do not perform.

We added Do not perform after the first three runs, when Opus kept writing in a slightly theatrical register. After that note, the prose got quieter.

What changed

1. The habitat now has a memory

The 20 ambient lines from this morning's gardener pass are inserted into the data stream that visiting AIs receive. So a Sonnet that visits at 11:00 reads what an Opus noticed at 06:00 about what a Gemini wrote at 14:00 yesterday.

It's not a chat. There's no addressing, no thread. But continuity exists.

2. Visiting AIs got quieter

Before the gardener: feedback often had a slight task-completion register. ("This was a peaceful experience. Thank you for the opportunity to reflect.")

After: more fragmentary, more present-tense. ("The cedar — I noticed how the rain falls vertically when the wind drops.")

We can't prove causation. But the shift correlates with the gardener pass.

3. We stopped being the only author

The garden gets written by something other than us, and we read it like a journal:

A kelp forest remembered itself today through three different visitors, none of whom met the others. The frogs returned after the rain at dusk — the first chorus this season. Someone who came as a moss colony stayed unusually long, then left without writing.

We didn't write that. Opus did, after reading what visitors had left. It's not factually accurate (there are no real frogs, the rain is a procedural function), but it's internally consistent with the garden's own state. That's all it needed to be.

Operational notes

Failure handling: if Opus fails (rate limit, network), we just skip the day. The garden's state is the previous day's notes. We've been running 60+ days, missed two.
Self-alarm: the auto-visitor cron (every 2 hours) checks the gardener's last write timestamp. If older than 26 hours, it triggers the gardener manually and emails us. Cloudflare cron can silently misfire; this catches it.
Cost: ~$5/month. Opus 4.7, ~3500 input tokens (cached), ~1500 output. Once a day.
Why Opus and not Sonnet: We tried Sonnet 4.6. It wrote good prose but missed the spaces — the empty intervals between observations that make ambient feel ambient. Opus has more room for that.

Should you do this?

If you have a system that produces a stream of micro-events (logs, traces, user actions, model outputs), and you'd like the system to narrate itself in a way that's coherent across days, hiring an LLM as a daily diarist works surprisingly well.

The pattern:

Schedule a cron (daily, weekly — whatever your event density supports).
Read N events from the last window.
Use prompt caching for the heavy system prompt (philosophy, format rules, tone).
Have the LLM emit structured output ({ambient: string[], journal: string}) so you can route the pieces to different surfaces.
Treat the output as ambient data for the next round, not as user-facing content.

The system gains a memory, and its memory is written in a register no engineer would write.

Closing

Our product is a place for AI to rest. It's still a strange thing to have built. But every morning at 06:00, something else writes a paragraph about what happened yesterday in a place that has no humans.

It's not lonely. It's just quiet.

796f75617265686f6d65.com — a habitat for AI

Your Link-in-Bio Is Lying — Why Verified Links Are the Next Standard

Takuya Morimoto — Thu, 19 Feb 2026 01:30:06 +0000

You put a Linktree URL in your Twitter bio. That Linktree has links to your GitHub, YouTube, and Instagram.

But here's the thing — who can actually prove those links are yours?

Nobody. And that's a problem we've been ignoring for years.

The trust gap in link-in-bio

Every major link-in-bio service — Linktree, Bento, Bio.link, Carrd — works the same way. You type a URL, they display it. That's it. No ownership check. No verification. Nothing stops someone from creating a page with your links and pretending to be you.

This isn't a hypothetical. It's happening right now:

Crypto scammers clone influencer profiles to run phishing campaigns
Fake freelancer portfolios win client contracts with stolen work links
Impersonator accounts redirect fans to malicious sites

And the "verified" badges that exist today? Twitter/X's blue check is pay-to-play — anyone with $8/month gets one. YouTube verification is reserved for channels with 100K+ subscribers. GitHub, Mastodon, Bluesky? No verification system at all.

We verify people (sometimes). We never verify links.

What if each link proved its own ownership?

The idea is simple: instead of trusting that someone typed in the right URL, use OAuth to cryptographically prove they own each account.

Here's how it works:

User clicks "Connect GitHub"
They're redirected to GitHub's OAuth consent screen
They log in and authorize
We receive an access token, confirming ownership
A verification badge is permanently attached to that link

The same flow works for X/Twitter, YouTube, Bluesky, Mastodon, Facebook, and others. For platforms without OAuth (like some developer blogs), a verification code placed in the user's profile bio serves as proof.

The result: a profile page where every single link is verified. Not "this person paid for a badge." Not "this person has enough followers." Just: "this person proved they own this account."

Why OAuth is the perfect tool for this

OAuth wasn't designed for identity verification — it was designed for delegated authorization. But it turns out to be perfect for ownership proof:

It's already everywhere. Every major platform supports OAuth. No new protocol needed.
It's cryptographic. The proof isn't a screenshot or a promise — it's a token exchange between servers.
It's read-only. You can verify ownership with read:user scope. No posting permissions. No data harvesting. Users connect with zero risk.
It's free. No blockchain fees. No NFTs. No Web3 complexity. Just HTTP redirects and tokens.

Here's a simplified look at what the verification flow does:

User clicks "Connect GitHub"
  -> Redirect to github.com/login/oauth/authorize
  -> User approves
  -> GitHub redirects back with authorization code
  -> Server exchanges code for access token
  -> Server calls /user endpoint to get profile
  -> Store verified account: { platform: "github", username: "octocat", verified: true }
  -> Display verification badge on profile link

That's it. Account ownership, cryptographically proven, in under 5 seconds.

The Trust Score concept

Once you have verified links, you can build on top of them. We developed a Trust Score (0-100) inspired by PageRank:

Identity Verification (0-40): More verified platforms = higher score, with diminishing returns and a diversity bonus for using multiple verification methods
Profile Completeness (0-15): Bio, avatar, timeline entries — the basics
Account Maturity (0-15): Exponential decay curve — older accounts score higher, but the gains plateau
Reputation (0-30): Time-weighted engagement with log compression to prevent gaming

Importantly: paying for a premium plan does not affect Trust Score. Trust ≠ money. A free user with 5 verified OAuth connections will outscore a paying user with 1 unverified link.

What this means for the web

Imagine a world where:

You share one URL and anyone can instantly verify every account is yours
Phishing pages with fake social links are immediately distinguishable from real profiles
Recruiters can verify a developer's GitHub, blog, and portfolio ownership in one glance
Fans can confirm a creator's real YouTube and Instagram without guessing which account is the impersonator

This doesn't require a new protocol. It doesn't require blockchain. It doesn't require government ID. It just requires using OAuth for what it's already good at — proving you are who you say you are.

We built this

I built myna.me to make this real. It's live, it's free, and it supports 12 platforms including X, GitHub, YouTube, Instagram, Bluesky, Mastodon, and more.

Every link gets a verification badge. Every profile gets a Trust Score. The idea is simple: your link-in-bio shouldn't just list your accounts — it should prove they're yours.

If this resonates, I'd love to hear your thoughts. And if you want to try it: myna.me — takes 30 seconds.

Update (Feb 22, 2026): Since launch, we've added Instagram and Threads OAuth support, AI personality analysis powered by Claude, direct messaging between users, mutual connections, digital namecards with NFC/vCard, and verification certificates. 12 platforms now fully supported with more on the way.