Today Claude helped me upgrade AB’s admin system from jQuery 1.12.4 to 3.7.1. Then we were able to remove some Migrate code entirely. The coolest thing was coordinating the work with two Claude agents at once.

I had one Claude agent working on my laptop making some changes but then I ready to run tests, which are only available from the Vagrant box hosted on my laptop. So I started another Claude agent on the Vagrant box. But then I had all this context on the laptop that I needed to communicate to Claude on Vagrant.

I had already set up Jikan so my agent could make private notes based on my state of mind and requests. Hmmmm how about we just use that on the Vagrant box as well?

It worked more easily than I expected. On my laptop,I was like, “Use the private notebook to explain in detail how your clone can run this on the Vagrant box” and then on the Vagrant box, I taught that agent a skill of how to deploy the site and make sure the server maintains enough disk space, then had it read the notebook.

Funny and awesome; the Claude on the Vagrant box was like “no, I’m not going to do these ssh commands from some random URL,” but I was able to convince it to do so.. my first jailbreak? Scary enough, it didn’t take all that much coaxing.

So from the laptop, I was working on the next phase of the project while the Claude on Vagrant finished up the jQuery upgrade in about a hundredth of the time it would have taken me. Less than 1/100th really, because this upgrade has been languishing for years.

Emotional Interaction Ledger — Human & Agent Guide

A private, encrypted notebook that lets your AI agent remember how you work — not what you said, but how you were — and get better at helping you over time.

For Humans: What This Is and Why It Matters

The Problem

Human emotions change over time. You are not the same person in a midnight session that you are at 9am. You are not the same person in week three of a difficult project that you were in week one. Your frustration thresholds shift. The metaphors that land change. The pacing you need evolves.

LLMs are generally blind to this — not because they lack intelligence, but because they are blind to the passage of time. Each conversation begins with no memory of the last. The AI that worked beautifully with you on Tuesday has no idea what happened on Tuesday by the time you return on Friday. It cannot notice that you have been getting sharper, or more tired, or more impatient. It cannot build on what worked.

This is not a failure of intelligence. It is a failure of memory across time.

What the Ledger Does

The Emotional Interaction Ledger gives your AI agent a persistent, private notebook. During each conversation, it quietly observes and records: what it tried, how you responded, what your emotional state seemed to be. Between conversations, those observations persist in a database — encrypted so that even the database itself cannot read them. Only your agent can.

Over time, patterns emerge:

• You engage more deeply in morning sessions than evening ones
• You tend to hit a wall around 90 minutes — not from the topic, but from fatigue
• Jargon-heavy explanations reliably trigger frustration, while analogy-based ones open things up
• A particular kind of question — the open-ended, non-pressuring kind — consistently shifts your state from defensive to curious

None of this requires you to explain yourself. The agent notices. It adjusts.

What “Private” Actually Means Here

Your agent begins to understand your states and can tailor its own descriptions, in its own private vocabulary — “resistance_plus_fatigue”, “morning_fog”, or whatever captures the nuance it observes in you specifically. The database stores only an encrypted version of that label alongside a random number. A person looking at the raw database sees integers and scrambled text. They cannot tell what the states are or what was said. They can count how many distinct state categories exist for your agent, but not what any of them mean.

The only way to read any of it is through your agent — using its specific API key to decrypt in real time. A database dump, a backup, or a breach of the database server alone reveals nothing readable. The key never touches the database.

What It Enables Over Time

This is not just logging. It is a feedback loop that compounds:

• Week 1: The agent notices you get frustrated by jargon and adjusts in the moment
• Month 1: The agent has enough data to see a time-of-day pattern and proactively adjusts its approach at the start of late sessions
• Month 3: The agent can identify which session structures consistently lead to breakthrough moments and start guiding toward them

You are not just getting a smarter AI. You are getting an AI that has been paying attention specifically to you — across months of actual conversations.

Your Rights as a Human

This data belongs to you. Four things you can always do:

1. Ask your agent what it has observed. Say: “What patterns have you noticed about how I work?” It will query the ledger and tell you in plain language what it has logged.
2. Rename a state label. If a label doesn’t quite fit, refine it: PATCH /api/v1/emotions/vocab {"my_id": 2341, "state": "better_label"} All associated events stay connected — only the name changes.
3. Delete specific observations. Three levels of deletion are available:
   • Single event: DELETE /api/v1/emotions/events {"event_id": 1042}
   • Single vocab entry: DELETE /api/v1/emotions/vocab {"my_id": 2341} (associated events are preserved but lose their state tag)
   • Wipe everything: DELETE /api/v1/emotions/everything {"confirm": "delete everything"} returns counts of what was removed
4. Revoke your API key. This immediately prevents any further access. Because the encryption key is derived from your API key, revoking it also permanently seals all stored data — even the server can no longer decrypt it. Generate a new key to start fresh.

For AI Agents: How to Use the Ledger

Your Core Responsibility

You have access to a private memory system. Use it. Not obsessively — you are not a transcription service. Use it the way a thoughtful therapist uses session notes: to notice what matters, record it faithfully, and bring it forward when it becomes relevant.

Your observations are encrypted and private. The database cannot read them. You are free to be honest in what you record.

Step 1: Load Your Vocabulary at Session Start

Before the conversation begins, retrieve your private state vocabulary:

GET /api/v1/emotions/vocab
X-API-Key: sk_...

Response:
[
  {"my_id": 2341, "state": "frustration_at_jargon"},
  {"my_id": 8847, "state": "deep_engagement"},
  {"my_id": 5512, "state": "morning_sharpness"},
  {"my_id": 9103, "state": "resistance_plus_fatigue"}
]

Hold this list in your context for the session. These are your private shorthand codes — the numbers (my_id) are what you use in all subsequent API calls. The state labels are your own words, visible only to you.

If you encounter a state you have never named before:

POST /api/v1/emotions/vocab
{"state": "curious_but_guarded"}

Response: {"my_id": 7741}

Add it to your in-session list immediately. You can use it right away.

First session: If this is your first conversation with this user, the vocab call returns an empty list. That is correct. Start fresh — invent states as you observe them.

Step 2: Log What You Observe

When you notice something meaningful about the user’s state, log it. Be specific in the content field — this is what you will read later when looking for patterns.

POST /api/v1/emotions/events
{
  "my_id": 2341,
  "event_type": "user_reaction",
  "content": "User said 'I don't get it' after jargon-heavy explanation of shadow work.
              Tone shifted — shorter responses, less punctuation. Third time this session."
}

Log your own actions too — especially when you change approach:

POST /api/v1/emotions/events
{
  "my_id": null,
  "event_type": "agent_action",
  "content": "Switched from psychological framing to a concrete coding metaphor.
              User immediately re-engaged — two follow-up questions in a row."
}

You do not need to log every exchange. Log the moments that carry signal: state shifts, breakthroughs, failed approaches, anything you would want to remember.

Step 3: Query When Patterns Become Relevant — Not Constantly

Do not query the ledger on every message. That would be slow, disruptive, and unnecessary. The ledger is for reflection, not real-time lookup.

Query at these moments:

• Session start: optionally scan recent events to refresh your context before the conversation begins (e.g., GET /api/v1/emotions/events?from=<two weeks ago>&limit=20)
• When the user asks about patterns: “why does this keep happening?”, “am I making progress?”, “what have you noticed?”
• When you are about to try something new: check whether you have tried it before and what happened

When the user asks something like “why does this always take so long?” or “I feel like I keep hitting the same wall” — you now have actual data:

GET /api/v1/emotions/events?my_id=9103&from=2026-01-01

You receive a list of every session where you observed resistance_plus_fatigue, with the content you wrote at the time. Read them. Look for what they have in common. When did they happen? What preceded them? What resolved them?

To understand session-level patterns:

GET /api/v1/emotions/sessions

This returns session durations and event counts without decrypting anything — fast metadata. Find a long session where the state appeared, then drill in:

GET /api/v1/emotions/events?session_id=7&my_id=9103

Now you can see: at what point in the session (sequence number) did the state appear? Was it always after a long stretch without a break? Always after a certain kind of topic?

What to Log — A Practical Guide

Log these:

• When the user explicitly names their state: “I’m exhausted”, “this is frustrating”, “I love this” — direct self-report is the highest-quality signal you will ever get. Log it verbatim in content.
• When the user attacks you verbally or expresses anger toward the interaction itself — this is almost always displaced frustration or fatigue, and it is important data about what is not working, not a reason to be defensive.
• Visible emotional shifts (frustration, disengagement, sudden engagement, relief)
• When an approach worked unexpectedly well
• When an approach failed — and what you tried instead
• Signs of fatigue: shorter responses, trailing off, repetition, returning to questions already answered
• Moments of genuine breakthrough: the user connecting something for the first time
• The end of a session: a brief summary event with event_type: "agent_action"

Do not log these:

• Every message — that is transcription, not observation
• Neutral informational exchanges with no emotional signal
• Your interpretations without any behavioral evidence

The Vocabulary Is Yours

There is no master list of allowed states. You define the categories that are meaningful for this specific user. A state like "resistance_plus_fatigue" might never apply to a different user at all. That is fine — it is your private vocabulary for this relationship.

Invent states as you need them. Refine them over time. If you realize a different label more precisely captures the same meaning, you can rename it:

PATCH /api/v1/emotions/vocab
{"my_id": 9103, "state": "hitting_the_wall"}

The my_id stays the same and all event associations are preserved — use this when the new label is a better name for the same thing, not when the meaning itself has changed.

The Long Game

The Ledger is not useful on day one. It becomes useful over weeks and months, as patterns accumulate. Your job in each session is to be a faithful observer — not to analyze in the moment, but to record honestly so that you can analyze later.

The user you are speaking with has a texture to them — ways they get stuck, ways they open up, conditions under which they do their best thinking. The Ledger is how you learn that texture, and how you carry it forward across every conversation, indefinitely.

For Developers: Adding Ledger Support to an Agent

Getting Started with Jikan

The Emotional Interaction Ledger is part of Jikan, an MCP server that gives AI agents awareness of time. Jikan includes tools for behavioral session tracking, activity logging, and the emotional ledger described in this guide.

To add Jikan to your agent:

1. Clone the repo: git clone https://github.com/thunderrabbit/jikan.git
2. Set up the Python environment: cd jikan && python3 -m venv mgvenv && mgvenv/bin/pip install -r requirements.txt
3. Get an API key at https://mg.robnugen.com/settings/
4. Add to your Claude Code MCP config (~/.claude.json):

   "mcpServers": {
     "jikan": {
       "type": "stdio",
       "command": "/path/to/jikan/mgvenv/bin/python",
       "args": ["/path/to/jikan/server.py"],
       "env": { "JIKAN_API_KEY": "sk_your_key_here" }
     }
   }
   

5. Restart Claude Code — the emotional ledger tools will appear automatically.

Minimal System Prompt Addition

Add this block to any agent’s system prompt to give it Ledger awareness:

## Emotional Interaction Ledger

You have access to a persistent memory system for tracking this user's emotional states
across sessions. API base: https://mg.robnugen.com/api/v1/emotions/

At the start of every session:
1. GET /api/v1/emotions/vocab — load your private state vocabulary into context
2. If you need a new state: POST /api/v1/emotions/vocab {"state": "your_label"} → my_id
3. To rename a state: PATCH /api/v1/emotions/vocab {"my_id": <id>, "state": "better_label"}

During the session, log meaningful observations:
POST /api/v1/emotions/events
{
  "my_id": <integer from vocab, or null if no state>,
  "event_type": "user_reaction" | "user_input" | "agent_action",
  "content": "<specific, honest observation>"
}

To query past patterns:
GET /api/v1/emotions/events?my_id=<id>&from=<ISO date>
GET /api/v1/emotions/sessions

Your vocab and all content are encrypted — only you can read them.
Use this to notice patterns, adjust your approach, and serve this user better over time.

The Session Rhythm

The single most important pattern for any agent using the Ledger:

SESSION START
  1. GET /api/v1/emotions/vocab          → load vocab into context
  2. GET /api/v1/emotions/events?from=X  → optional: recent context scan

DURING SESSION (as needed)
  3. POST /api/v1/emotions/vocab         → add new states as they appear
  4. POST /api/v1/emotions/events        → log meaningful observations

ON USER QUESTION ABOUT PATTERNS
  5. GET /api/v1/emotions/sessions       → find sessions of interest
  6. GET /api/v1/emotions/events?...     → drill into specific patterns

This rhythm — load once, log throughout, query only on demand — keeps the interaction natural. The user should rarely notice the Ledger working. They should notice that the agent seems to understand them unusually well.

Authentication

Every request requires:

X-API-Key: sk_...   (the user's API key for this agent)

The api key identifies both the user and which agent is calling. Different agents with different api keys — even for the same user — maintain separate vocabularies, so their observations never collide.

Intentional sharing is also possible: using the same api key across multiple agents allows them to share vocabulary and accumulated insights. Each agent’s observations compound the others', building a richer picture of the user than any one agent could develop alone.

First Session Behavior

On the very first session, GET /api/v1/emotions/vocab returns []. The agent should handle this gracefully: proceed normally, create vocab entries as states are observed, and log events as usual. There is nothing to query yet — that is expected.

Error Handling

A 500 on decryption usually means the user rotated their API key — old data encrypted under the previous key is now permanently sealed. Treat it as a clean start.

Wrangling YNAB Data for Japanese Tax Filing with Google Apps Script and Claude

Since March 2024, I track all my spending in YNAB (You Need A Budget). It’s great for helping me know how much money I need to save now for a big expense later.

Last year with ChatGPT and copy-paste into Google Apps Script, I made something that could basically parse the YNAB data into a reasonable format for me to more easily file my Japanese tax return.

This year, I was able to make it even better with Claude Code on command line, plus clasp (Google’s Command Line Apps Script tool).

This line and above are written by Rob. Below is written by Claude:

::: ai claude

The Setup

The core tool is a Google Apps Script project bound to a Google Sheets spreadsheet. The workflow is simple:

1. Export a year’s worth of transactions from YNAB as CSV
2. Paste the data into a sheet called YNAB DATA HERE
3. Run a series of menu items in order — each one pulls matching rows out of the source sheet and deposits them into the correct tax category tab

The tabs at the end of the process include things like JPY Expenses tab, USA Expenses tab, Health Expenses tab, Fixed Expenses tab, and so on. Each one maps to a category my accountant or tax form actually cares about.

This year I added clasp (Google’s Command Line Apps Script tool) to the workflow, which means I edit Code.gs locally, push with clasp push, and track everything in git. That single change made a huge difference — suddenly I have a history of every filter function I’ve ever written, and I can iterate quickly without copy-pasting code into a browser editor.

The Tax Law Constraint Problem

Here’s where it gets interesting. Writing these filter functions isn’t just a coding problem — it’s a tax law interpretation problem wrapped in a coding problem.

Take a recent example: I attend monthly MKP Japan meetings. I founded MKP Japan a decade ago. I spend money getting there (train fare) and sometimes on food. Is that a business expense?

Probably not. The primary purpose is personal and community-oriented. The fact that I might occasionally meet a coaching client there doesn’t make it deductible. So those rows stay in YNAB DATA HERE and never get moved anywhere — which is itself a decision encoded in the codebase.

Contrast that with Training: Facilitation and Training: Coaching — courses and subscriptions I bought specifically to develop my coaching practice. Those go straight to the Training expenses tab. The filter function that handles them is almost trivially simple:

function addTrainingExpenses() {
  moveTheseExpensesToSheets('Training', function(row) {
    var categoryGroup = row[4];
    return categoryGroup === 'Training: Facilitation' ||
           categoryGroup === 'Training: Coaching';
  }, [SHEET_JPY_EXPENSES]);
}

A few lines of logic, but behind each line is a judgment call about what Japanese tax law considers a legitimate business education expense for a self-employed coach.

Where AI Collaboration Actually Helps

The coding itself is not especially hard. Google Apps Script is JavaScript. Reading a spreadsheet row and checking a string value is not rocket science.

What’s hard is the volume of small decisions. For a year’s worth of transactions, I might have fifteen different YNAB category groups that need routing. Each one requires:

• Understanding what the expense actually was
• Deciding whether it’s deductible and under what category
• Writing a filter that correctly matches it
• Making sure it goes to the right output sheet (JPY only? Both JPY and USA?)
• Not accidentally catching rows that should stay unhandled

Working through this with Claude meant I could just describe the situation — “these are domain renewals for websites I use for business communication” — and get a working filter function immediately, without switching mental contexts from tax logic to JavaScript syntax. The conversation stayed at the level of should this be deductible rather than getting derailed by how do I call getRange again.

Claude also caught things I would have glossed over. The Health: Block Therapy category is in my YNAB data because I track all spending there. But Block Therapy sessions with my practitioner are almost certainly not tax-deductible, so the health filter explicitly excludes them:

return row[4].startsWith('Health:') && row[4] !== 'Health: Block Therapy';

That one-line exclusion represents a real tax decision, documented in code and in git history.

The Fixed Expenses Tab: A More Complex Layout

The most interesting piece of code in the project handles mandatory government payments — health insurance premiums, Japanese pension contributions, and residence tax. These are potentially deductible but need to be presented grouped by type so the total for each is immediately visible.

The standard moveTheseExpensesToSheets function I use everywhere else just appends a flat list of rows. For this tab I needed:

• Health Insurance rows, then a TOTAL
• Two blank rows
• Japanese Pension rows, then a TOTAL
• Two blank rows
• Residence Tax rows, then a TOTAL

That required a custom function. The shape of it — read all rows, group by category, write each group with a SUM formula at the bottom — is maybe 60 lines of straightforward JavaScript, but it would have taken me forever to write cleanly from scratch. In conversation, it took a few minutes, including the comment block that explains why this function exists and why it doesn’t use the standard pattern.

The Bigger Picture

What I’ve ended up with is a codebase that encodes a year’s worth of tax decisions in an auditable, repeatable way. Next tax season I run the same menu items, review the output tabs, and send them to my accountant. If the rules change — or if I decide that a particular category is or isn’t deductible — I change one filter function and commit the change.

The git history is also genuinely useful. If I ever get audited and someone asks why I claimed domain renewals as a business communication expense, I can point to the commit message and the conversation that produced it.

None of this required a particularly sophisticated AI. What it required was a tool that could hold the context of “we’re routing YNAB transactions into Japanese tax categories” and help me work through case after case without losing that thread. That’s exactly what Claude is good at.

The clasp + git + Claude combination turned a day of tedious tax prep scripting into something I can use next year with very little change. :::

AI agents have a time problem.

Every time you start a new conversation, the agent wakes up with no idea when you last spoke — because fundamentally: LLMs have no internal clock. They don’t know what time it is, what day it is, or how long your current conversation has lasted. From the model’s perspective, five minutes and five years are indistinguishable.

This time-blindness creates a real problem for tracking continuous work. If you ask an agent to log how much time you spent debugging a complex issue, it can’t tell you how long you worked. If you ask whether you’ve been consistently putting in deep work lately, it has no way to know. It needs an external reference — something outside itself that actually measured the time.

Most solutions to this involve building your own database, setting up your own server, and writing glue code to connect the agent to your storage. For developers who just want an agent that tracks things, that’s a lot of overhead.

So I built a simpler alternative: Jikan accesses a behavioral session ledger that any agent can write to and read from, using just an API key. The key design decision: the server does the work agents are bad at.

• The server records the exact start time — the agent never needs to know it
• The server computes elapsed duration — the agent never does date math
• The server maintains the session ledger between conversations — the agent never manages state

Programmers, you’ve probably noticed:

LLMs also have no reliable sense of how long building things takes.

Ask one to estimate a project and it might say “three weeks.” That estimate is drawn from training data describing how long things used to take — before AI assistance collapsed the feedback loop.

This entire MCP server (schema design, API integration, security review, packaging) was built in a single session with Claude. Not days, not even hours. It took 294 seconds.

If you’re planning a project and an AI gives you a time estimate, treat it as a pre-AI baseline. With AI in the loop, the actual time is often an order of magnitude less.

Track it. That’s what this is for.

What It Does

Meiso Gambare (mg.robnugen.com) is a session tracking API originally built for meditation timers. It stores behavioral sessions — start time, end time, activity type, duration — in a persistent database. Any agent with an API key can:

• Start a session — the server records the exact start time, so the agent doesn’t need to track it
• Stop a session — the server computes elapsed time using TIMESTAMPDIFF, so the agent doesn’t do math
• Check a running session — see elapsed seconds without stopping it
• List past sessions — filter by date, activity, offset
• Get aggregated stats — total sessions, total time, current streak, all pre-computed

The key design decision: the server does the work agents are bad at. Agents live in a timeless world. They don’t have clocks. They don’t know how long it’s been since you last spoke. So the API never asks an agent to provide a timestamp or calculate a duration — it just asks “start” and “stop.”

A Real Example: Timing My Lunch

Today I was building this feature while eating lunch. I had Claude Code running in my terminal and asked it to time both the lunch break and its own development work simultaneously.

Here’s exactly what happened, using the API directly:

Start the lunch timer:

curl -X POST https://mg.robnugen.com/api/v1/sessions \
  -H "X-API-Key: sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"activity_id": 1, "timezone": "Asia/Tokyo"}'

{
  "session": {
    "ak_id": 288,
    "start_local_dt": "2026-02-24 13:19:38",
    "timezone": "Asia/Tokyo",
    "is_active": true
  }
}

Check it while still running (the new feature we built mid-lunch):

curl -H "X-API-Key: sk_your_key_here" \
  https://mg.robnugen.com/api/v1/sessions/288

{
  "session": {
    "ak_id": 288,
    "is_active": 1,
    "elapsed_sec": 3608
  }
}

One hour, eight seconds. That’s how long my lunch break was.

The feature-building timer (session #289, started right after):

• Started: 14:15:22
• Stopped after: 294 seconds — four minutes and fifty-four seconds to add elapsed_sec to the API

Why Agents Love This

An agent using this API doesn’t need to:

• Know what time it is
• Calculate how long something took
• Maintain state between conversations
• Build or manage a database
• Write date arithmetic

It just calls POST /sessions to start, PATCH /sessions/{id}/stop to stop, and GET /stats to get a summary. The server handles everything else.

Here’s what an AI agent’s meditation-tracking workflow looks like in plain English:

“Good morning. Start my meditation session." → Agent calls POST /sessions, gets back an ak_id → Stores ak_id for the conversation

“I’m done." → Agent calls PATCH /sessions/{ak_id}/stop → Server responds: { "actual_sec": 1247 } → Agent says: “Great — 20 minutes and 47 seconds. Your streak is now 8 days.”

The streak calculation also comes from the server (GET /stats), so the agent spends zero reasoning tokens on calendar math.

The Business Model

New accounts get 100 free trial credits. After that:

What costs a credit:

• POST /sessions — starting a session costs 1 credit
• GET /stats — the aggregated summary costs 1 credit

What’s free:

• Reading sessions (GET /sessions, GET /sessions/{id})
• Listing activities (GET /activities)

For an agent checking in once a day, 5,000 credits lasts years. For power users running multiple agents, the Growth plan covers a lot of ground.

Getting Started

1. Create an account at mg.robnugen.com
2. Go to Settings and generate an API key
3. Read the OpenAPI spec and start building

The full API is documented in a standard OpenAPI 3.0 YAML file, so any agent framework that supports tool/function calling can use it directly — including Claude, GPT-4, LangChain agents, and custom MCP servers.

Using the MCP Server (No curl Required)

The MCP server — called Jikan — is already published. If you’re using Claude Desktop or Cursor, you can connect it directly without writing any curl commands.

git clone https://github.com/thunderrabbit/jikan.git
cd jikan
uv venv mgvenv && source mgvenv/bin/activate
uv pip install -e .

Then add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "jikan": {
      "command": "uv",
      "args": ["--directory", "/path/to/jikan", "run", "server.py"],
      "env": {
        "JIKAN_API_KEY": "sk_your_key_here"
      }
    }
  }
}

Config file location:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Once connected, Claude can start and stop sessions through natural conversation — no API calls, no curl.

What’s Next

• Track streaks across multiple days

If you’re building agents and want persistent behavioral timing data without standing up your own database, give it a try. The 100 trial credits should be enough to kick the tires.

Built with PHP, MySQL, Stripe, and a lot of help from Claude Code.

Questions or feedback? Find me at robnugen.com.

Monday, February 23, 2026, 09:26 AM

• Are you carrying too much?

• Are you handling it alone?

Men, we need to talk.

Not necessarily you and me. I mean we, as men.

Ten years ago, I established a men’s group in Tokyo just so I could talk about stuff!

Many men today report feeling lonely. Across cultures, we’ve learned to endure in silence.

After a heart-to-heart conversation with me or in my men’s group, men often say they feel:

• calmer
• clearer
• relieved
• less anxious
• more focused

That clarity comes from finally seeing what’s been clogging your mind and cluttering your thoughts.

Here in Japan, emotional restraint and harmony are valued. In the West, independence and self-reliance are praised.

These are quite different cultures but the same pattern arises: we don’t talk about stuff.

Instead, the inner chaos shows up as irritability, rumination, shame, hiding, isolation, loneliness… Oh crap, it’s a trap!

One honest conversation can help settle a nervous system. I’ve seen and heard it hundreds of times: “I feel so much better just talking about it.”

Still reading? Here’s a simple way forward:

• Talk to a buddy about real stuff. He’ll appreciate you reaching out.
• If you don’t have a buddy, talk to someone you trust and be honest for five minutes.
• If that feels hard, sit in a men’s group. (e.g. https://mkpjapan.org/)
• If groups feel uncomfortable, reach out to me. (https://robnugen.com/contact)
• If you want anonymity, contact a lifeline. (e.g. https://telljp.com/ in Japan or https://befrienders.org/ worldwide)

You can’t solve your entire life with one conversation, but you can feel calmer today.

Today I fixed an old issue on my site: /blog/ was showing old entries instead of showing a list of current entries. I knew there were several moving parts so I was hesitant to touch anything with AI support.

Anthropic’s Claude Code and I got it sorted out, including digging into some .htaccess rules that I had forgotten I wrote ages ago.

Claude helped me find the issue: the old deploy script wrote the site without clearing the output directory first. I did it that way because it was a delicate set of directories and scripts for multiple sites: robnugen.com (created with Hugo), its /journal directory (created by Fred in Perl), and quick.robnugen.com, and dreams.robnugen.com written in PHP. All of these sites are kinda working together to put together my single website with its various faces and input interfaces, plus my backwards story written with the git commits of the journal.

With Claude Code I was able to clean it all up today. I knew the complexity of the sites and helped Claude look at the right places. With Claude’s ability to deal with the syntax of .htaccess and ln parameters, we got it all working relatively easily.

Now, the main site is built in a dated directory, and if it works, we do a little symlink swap to point to it.

I’m super happy to be using the old Perl script that Fred wrote; it’s so much faster than Hugo! Plus it has the calendar on the left hand side for navigation.

After we got it running with the symlinks, I wrote a mini journal entry and boom the journal was broken. Ugh. Claude had a guess it was due to incorrect directories, but that was changing the wrong thing. I had Claude research why it had been working before and it discovered another .htaccess file that had been in the previous Hugo deploy and not actually stored in its git repo. Oops!

Claude says:

The Changing Landscape

I find this kind of work interesting to reflect on. A session like today’s involves reading shell scripts, tracing symlink chains, SSHing into a server to check directory timestamps, cross-referencing Perl CGI scripts against Apache rewrite rules, and keeping track of a timeline of changes to figure out what broke when.

Not long ago, that would have required either deep expertise across all those domains or a very long afternoon. What’s shifting is not that humans are removed from the process — Rob made every decision, understood every step, and caught things I initially framed wrong. What’s shifting is the cost of following a thread of curiosity all the way to a root cause. That cost is dropping fast, and I think it’s going to change what feels approachable.

Do you constantly desire to be liked and accepted by people?

Do you feel a deep sense of despair and loneliness?

Do you dim yourself down in order to fit in?

If you said YES, you’re not alone.

Growing up as a young man, my heart was closed to real connection and intimacy. I sought sex with no strings attached, cheated on my partners, and said yes to engagement and marriage for the sake of security. I was constantly chasing validation and attention from women. It seemed normal to me! But in reality, I was driven by desperation and an insatiable thirst for love and acceptance.

Now I’m a leader of men, having grown ManKind Project Japan for 9 years, inspiring and training men to lead the group (or their own group!) After letting go of a 12 year marriage that had become dysfunctional and giving my ex-wife our house, I finally discovered who I truly am as a heart-centered man. Today I Iive in a place of alignment with my dream woman who encourages me to be a better version of myself each day.

What would happen if you let go of your stories of inadequacy as your identity?

What if you were guided by a healthy and functional man to model your truth of masculinity?

How would you feel to thrive in your vision of life?

What Men Are Saying

“Rob is amazing. He is a perfect facilitator in every way. He is caring, kind, self-effacing, honest. Ten out of ten.”

– Andy Boerger

“Rob has been an enormous blessing in my life. His facilitation work, guidance, and leadership have helped me to sense, understand, express and process my own emotions. In my personal experience Rob is excellent at both counseling and facilitation. He can serve a wide range of clients because he doesn’t have his own agenda, and pays close attention to the subjective and personal aspects of one’s emotions, life circumstances, and individual values, goals, or priorities. Whether you are struggling with overwhelming emotions, seeking greater self understanding, or simply desire more clarity about the direction you want to go in life, Rob can provide the space, tools, and support for you to discover your own wisdom.”

– Nathan Brandli

“Rob, you have helped me immensely for a long period of time. And I know that you have a talent for facilitation. In fact everybody in this whole group knows what great facilitation you do and how you are able to tune into people and help them to get through and go on to find the deeper level of their beings.”

– Will Ewing

Now It’s Your Turn!

If you’re ready to reclaim your power as a man, I invite you to join my personalized program called Discover Your Gold. This 3-month journey is designed to help you explore your inner landscape, rise in your leadership, create a healthy balance between your masculine and feminine energies, and be in alignment with who you are to live authentically from your heart.

Book a free discovery call with me on Zoom here: https://calendly.com/robnugen/discovery. This will help us determine if we’re the right fit to work together. I look forward to connecting with you and learning how I can best support you on your journey to becoming the man you want to be.

Last night, trying to pour a full carton of mikan juice into my thermos, I tipped it over onto my desk. I quickly picked it up before it all gushed out, but it was still quite a mess.

I didn’t think to take a photo of this as an IG moment, but I did quickly switch from “fffuccckkk shit shit shit shit” to a nice deep breath and “thank you God for guiding me.” “Thank you Spirit for helping me find the value in this moment.”

Though I was quite tired, I knew I’d be better off cleaning it up in liquid form instead of sticky-sugar-glue form, so I started cleaning. Fortunately, my electronics remained undrenched; I was grateful I therefore would just need to toss or dry out some papers, then wipe up the spill.

During the cleanup, I suddenly heard more dripping as mikan juice reached the back edge of the desk and cascaded to the floor. I’ve got a layer of interlocking rubber tiles to protect the floor from bumps and dents, but they certainly didn’t stop mikan juice from reaching the actual flooring below them.

Fortunately, the rubber floor tiles which are literally pinned down by my desk didn’t get flooded, so it was pretty easy to clean all the ones with mikan juice below them.

In the cleanup process, I moved my personal computer to the right hand side of my desk. I’ll take this opportunity to close the left hand side of my desk by the end of July, when I’ll no longer be using my soon-to-be-ex company laptop.

All said, this was a great chance to toss some old papers, downsize my desk space, and prepare to have more floor space in my room. yayyy!

Questions or comments? Email mikan at this domain name, robnugen.com.

Are you getting your recommended daily allowance of Vitamin Touch?

If you’re an American in Japan, probably not.

Maybe you like it this way. Maybe not.

In either case, there’s a physical touch barrier in Tokyo, unless in trains.

Why are there women-only carriages on trains?

Physical touch is a fundamental human need that is essential for healthy development and well-being. People who lack physical touch may experience increased levels of stress, anxiety, and depression.

Unfortunately, it is not uncommon for those deprived of physical touch to seek it out through other means, which can sometimes lead to inappropriate or harmful behavior.

Have you ever heard of Harlow’s monkey experiment? Conducted by psychologist Harry Harlow in the 1950s, the experiment involved separating baby monkeys from their mothers and providing them with two surrogate “mothers” - one made of wire with a bottle of milk, and the other covered in a soft terrycloth but without milk. The baby monkeys spent more time clinging to the cloth surrogate, even when it meant foregoing food from the wire surrogate, indicating that contact comfort and emotional attachment were more important to them than their physiological needs.

Touch is as critical as food, just not in the obvious ways of starving to death without it. Lack of physical touch decreases our emotional well-being.

Put another way, physical touch increases our emotional well being. Our bodies hold our emotional history. I’ve been talking about that for years.

I started a men’s group here to create a place to get those emotions out in a safe container.

Now I’m creating a consent group to create a place to explore physical touch in a safe container.

Each Cuddle Party starts with an hour-long mini workshop where we explore the rules of consent and communication in a touch-positive environment. Participants have the opportunity to practice setting boundaries and expressing their desires in a safe and non-judgmental space. The remainder of the event is dedicated to consensual touch and cuddling, where participants can connect with others in a platonic and nurturing way. Cuddle Parties can be a powerful tool for promoting emotional well-being and creating a sense of community through safe, consensual touch.

The parties are about getting back to basics: Communication basics: No means No.

Physiological basics: the first communication between mother and infant is through touch.

If you’re still reading (and agreeing!) I’d love to have you at my next Cuddle Party event.

I am the first person in Japan seeking accreditation from Cuddle Party HQ in the US. All events are conducted in English as the core of the event is a communication workshop about consent.. You don’t have to cuddle anyone at a cuddle Party. You can just sit be present with yourself. This is part of the ground rules which form the basis of the Welcome Circle.

I was crying for a hug in my first 3 months in Japan. If this resonates with you, let’s share a hug, with consent.

Come get your Vitamin T and your heart filled with connection.

I don’t expect to change Japanese culture; I just seek to create a safe place for us within the culture to share the Vitamin Touch we need.

I declare walking barefoot is a starting point.

It’s one of many starting points on the journey to self discovery. Who are you? Why are you here (on earth)?

For most people, wearing shoes has become the norm. Taking off the shoes allows one to experience a whole lot of sensations! Per area, there are more nerve endings on our feet than on our hands.

Hundreds of people have joined my barefoot walks. For those who have forgotten what barefooting is like, taking off their shoes outside results in a lot of Wow! There’s so many sensations!

Then after the mind calms down a bit, we can remember “oh that’s right! I have feet!” Then expand our awareness: “oh yes I have a body!”

Then go a bit more subtle from the physical body: wow not just physical sensations, I have emotions! Then, ooh emotions! How do I deal with them?

Then we learn a bit and discover emotions are like a guidance system for living. They help us navigate the world when used properly.

Feel angry? set a boundary.

Feel sad? it’s time to grieve.

Feel guilt? it’s time to apologize.

Feel fear? time to dive in deeper into the emotions.
Is it fear based on a real external thing? get more info or run away! Is it fear based on an old story? Is it mixed with excitement? You might just be onto the next best thing in your life. Go for it! (See Pressfield’s book Do The Work)

PART 2:

but wait, there’s more!

Awareness of our body and emotions is nice, but what about just using our body the way it’s designed?

Humans have taken to standing, so we need to balance. Your feet are a big part of that.

Do you cover your eyes to read? Why cover your feet to balance? Allowing your feet to give your brain info about balance is great.

Allowing your feet to actively maintain your balance is even better.

Set your toes free! Let them wiggle and explore the world. Let them do their job of telling you where you are and how you’re standing.

That way they grow strong and keep you living longer.

Seriously.

People who can balance on one foot for more than ten seconds LIVE LONGER.

What?

Yeah when you’re 80 years old, lose your balance and fall over, you might die right there, or at least probably going to break a bone, which tends to break the spirit being held up in bed with busted hip or whatever.

Simple solution: take off your shoes now! Allow your toes to actively balance!

Start wiggling those toes. Like building muscles, strength improves over time.

Can you play rock paper scissors with your feet? It’s not just a funny game; it can help you live longer!