Forem: J Now

Eleven behaviors Anthropic measured. Which ones do you actually use?

J Now — Wed, 06 May 2026 19:24:30 +0000

In February 2026, Dakan and Feller published an AI Fluency Index built from 9,830 Claude conversations, classifying 11 observable collaboration behaviors across three axes: Description, Discernment, and Delegation. I ran their taxonomy against my own Claude Code sessions and found I was hitting maybe four of the eleven with any regularity. The rest were behaviors I'd read about but never actually triggered in practice.

That gap is what skill-tree is for.

The tool installs as a Claude Code plugin — claude plugin marketplace add robertnowell/ai-fluency-skill-cards && claude plugin install skill-tree-ai@ai-fluency-skill-cards — and on each session analyzes your message history against those same 11 behaviors. It assigns one of seven archetype cards (rendered as tarot cards with museum art, live example at skill-tree-ai.fly.dev/fixture/illuminator) and designates one behavior you haven't touched as a growth quest for your next session. That quest persists via a SessionStart hook so Claude surfaces it when you open a new conversation.

The classification runs remotely on Fly.io in 30–60 seconds: extract user messages, classify against the fluency framework, assign archetype, synthesize narrative, render, return a stable URL.

The archetype isn't the point. The point is the gap list — behaviors you're systematically skipping without knowing it. Seeing "Discernment" axis behaviors at near-zero across 40 sessions is harder to ignore than a vague sense that you might be in a rut.

Also available as an MCP server (npm install skill-tree-ai) for Cursor, VS Code, and Windsurf.

github.com/robertnowell/skill-tree

Why WCAG failed my terminal theme and what I used instead

J Now — Wed, 06 May 2026 17:29:00 +0000

Spent an afternoon watching pure IKB disappear against a dark ground. WCAG 2.1 contrast ratio for IKB (hex 002FA7): 3.2:1 — technically a pass for large text. APCA Lc score: -12 — effectively invisible. WCAG uses a symmetric formula that assumes light backgrounds; on dark ground it systematically overstates how readable dark colors are. APCA accounts for polarity, so the score for dark-on-dark reflects what actually happens.

That failure drove most of the design decisions in klein-blue, a set of four Terminal.app themes for Claude Code tuned for prose legibility over long sessions.

The split that came out of it: pure IKB lives in the ansi:blue slot — decorative borders and highlights where it reads as color, not text. A lifted Klein-family blue (A8BEF0) goes in ansi:blueBright — the slot Claude Code uses for permission-prompt text, where you actually need to read it. Same hue family, but the lifted value passes the body-prose gate (Lc >= 90) instead of sitting at -12.

APCA gates I used per role:

body text:   Lc >= 90
subtle text: Lc >= 75
muted text:  Lc >= 45
accent:      Lc >= 60

Of the four variations, only Klein Void Prot passes every gate strictly. The others make deliberate tradeoffs — Klein Void Gallery accepts maximum IKB presence at the cost of some accent scores; Klein Void Sand & Sea lets the claude-sand ansi:redBright slot compete as a second hero color instead of neutralizing it.

One setup requirement worth knowing: Claude Code has to be set to dark-ansi in its /theme picker. If you leave it on the default, Claude Code overrides everything with its hardcoded RGB palette and the ANSI theme does nothing.

https://github.com/robertnowell/klein-blue

Every work email in French was a task. Now it's a lesson.

J Now — Wed, 06 May 2026 13:47:52 +0000

I was writing a work email in French — intermediate level, still learning — and needed to say something like "I'll follow up with you next week." Google Translate gave me one option. I used it. I have no idea if it sounded like a colleague or a legal document.

konid returns three options for anything you want to say, ordered casual to formal, with a note on when each one fits. For that French sentence, the difference between option one and option three is the difference between how you'd write to a teammate versus a client you've never met. That gap is exactly what daily translation tasks contain — and what literal tools throw away.

The audio pronunciation plays through your speakers via node-edge-tts, no API key required. Supports 13+ languages: Mandarin, Japanese, Korean, Spanish, French, German, Portuguese, Italian, Russian, Arabic, Hindi, and more.

Installs as an MCP server in one line:

claude mcp add konid-ai -- npx -y konid-ai

Works in Cursor, VS Code Copilot, Windsurf, Zed, JetBrains, and Claude Cowork. Also runs as a ChatGPT app via Developer mode with the endpoint https://konid.fly.dev/mcp.

The idea is that if you're already translating work emails every day, you're sitting on 5–10 moments per day where you could either get an answer and move on, or get an answer plus understand the register tradeoff. konid tries to make those moments the latter.

MIT licensed. github.com/robertnowell/konid-language-learning

Designing email campaigns blind: how a design score changes the loop

J Now — Wed, 06 May 2026 11:45:19 +0000

Spent two years watching email marketers do the same thing: drag blocks around in Klaviyo for an hour, send a test, squint at it on mobile, change the CTA button color, send another test. No feedback until the open rate came back three days later.

kopi generates a complete HTML email from a text brief in under 5 minutes, then runs an automated design critique before anything ships. Every email gets scored 0-100 across 12+ criteria: layout hierarchy, CTA contrast, mobile readability, whitespace distribution, font legibility. The score isn't decorative — it tells you which specific element is dragging the number down.

A flash-sale email from the public gallery at trykopi.ai/emails scored 91/100. The critique flagged one thing: secondary CTA was competing visually with the primary button at near-identical contrast ratios. That's the kind of feedback that used to require a senior designer on a review call.

The critique runs on the same criteria every time, which means you're not getting a different answer depending on who reviewed it last Tuesday versus today.

If you're already in Klaviyo, there's a direct export. If you work in Claude Code or Cursor, kopi runs as an MCP server so you can generate and critique inside your existing editor. Brand-specific design systems are supported — it learns your fonts, colors, and layout preferences so generated emails don't need to be re-styled to match your kit.

The gallery has 400+ emails all scoring 80+: trykopi.ai/emails

Repo and docs: trykopi.ai

Why my Claude Code skill-tree plugin has two state paths

J Now — Tue, 05 May 2026 19:07:32 +0000

Built skill-tree to answer a specific question: am I actually developing new collaboration behaviors with Claude, or just running the same handful faster? Anthropic published a study in February (9,830 conversations, 11 observable behaviors) and I wanted my own sessions classified against that baseline.

The plugin classifies those same 11 behaviors from the Dakan & Feller 4D AI Fluency Framework, assigns one of seven archetype cards (rendered as tarot cards with museum art), and picks a behavior you haven't tried as a growth quest for your next session. The quest persists across sessions via a SessionStart hook.

That persistence is where the interesting constraint showed up.

Claude Code has a stable home directory, so state goes to ~/.skill-tree/ and that's that. Cowork's $HOME is ephemeral — anything written there is gone when the session ends. Which means a growth quest written to $HOME/.skill-tree/quest.json after session one doesn't exist when session two starts. The plugin never fails loudly; it just silently loses your state and picks a new quest as if you're a first-time user.

The fix is one conditional and one env var:

if os.environ.get("CLAUDE_PLUGIN_ROOT"):
    state_dir = Path(os.environ["CLAUDE_PLUGIN_ROOT"]) / ".user-state"
else:
    state_dir = Path.home() / ".skill-tree"

$CLAUDE_PLUGIN_ROOT is durable in Cowork even when $HOME isn't, so quest state survives there. Claude Code doesn't set that variable, so it falls back to the home directory path.

Small thing, but it's the kind of environmental difference that only bites you after you've watched a user lose their progress and gone looking for why.

Install in Claude Code: claude plugin marketplace add robertnowell/ai-fluency-skill-cards && claude plugin install skill-tree-ai@ai-fluency-skill-cards

Example archetype card: skill-tree-ai.fly.dev/fixture/illuminator

github.com/robertnowell/skill-tree

Klein-blue: four terminal themes tuned for prose, not syntax

J Now — Tue, 05 May 2026 17:16:15 +0000

Most terminal themes were built for code. When your screen is 80% tool output, reasoning blocks, and permission prompts, you're reading paragraphs — not syntax. The contrast relationships that matter are different: body text needs to hold up at 11–13px over a four-hour session, not just pop on a hero slide.

klein-blue ships four variations, each making a different call about one specific question: what do you do with the ansi:redBright slot?

Claude Code uses that slot for its claude-sand brand color — a warm amber that appears on certain UI elements. That's the fork in the road. Neutralize it so nothing competes with Klein blue, or accept it as a second hero and let the two colors coexist. The four variations are four answers:

Klein Void Refined — balanced, sand neutralized, no strong brand color presence
Klein Void Sand & Sea — accepts claude-sand as a second hero alongside IKB
Klein Void Prot — fully APCA-verified; every accent role passes strict gates (body Lc >= 90, subtle >= 75, muted >= 45, accent >= 60)
Klein Void Gallery — maximum void, one blue, everything else steps back

The IKB problem is real: pure International Klein Blue on a dark ground measures Lc -12 under APCA — effectively invisible as body text. The fix is a split across two ANSI slots. Pure IKB stays in ansi:blue for decorative borders and highlights. Readable permission-prompt text moves to ansi:blueBright, lifted to a Klein-family hue that actually passes body-size gates.

Ships as macOS Terminal.app .terminal profiles with CommitMono-Regular and IBM Plex Mono bundled to ~/Library/Fonts/. One prerequisite: Claude Code's /theme picker must be set to dark-ansi, otherwise Claude Code ignores the ANSI layer entirely and renders from its hardcoded RGB palette.

git clone https://github.com/robertnowell/klein-blue
cd klein-blue
bash install.sh

https://github.com/robertnowell/klein-blue

Inline context without losing your place in the article

J Now — Tue, 05 May 2026 15:31:08 +0000

I was reading about the Dreyfus affair and hit "syndicalism" — a word I'd skimmed past a dozen times. I knew the shape of it, not the substance. Opening a new tab meant losing the paragraph I was in, reorienting, reading something adjacent, and coming back with my thread broken.

rabbitholes is a Chrome extension that solves the specific version of this problem: you want the context, but you don't want to leave.

Highlight any text and a shadow-DOM tooltip renders an explanation next to your cursor — Claude Haiku 4.5, direct from your browser to api.anthropic.com, no intermediary server. Shadow DOM means the tooltip doesn't touch the host page's styles or DOM; you can close it and the page is exactly as you left it.

The part I use most: every word in the response is itself clickable. You can drag across a phrase to select it. So when the explanation of "syndicalism" mentions "anarcho-syndicalism" and you want that too, you don't open a tab — you click the word. The extension tracks depth with a hop counter. Go far enough and you get a shareable trail of what you followed.

There's also a globe icon that re-answers the query enriched with Brave Search results, with clickable source chips. That's useful when you want primary sources rather than an explanation.

The architecture choice I'd defend: storing your Anthropic key in chrome.storage.sync (encrypted, never leaves the browser) and routing directly to Anthropic's API instead of proxying through a server. It's slightly more setup friction for the user, but zero telemetry and no service dependency felt like the right trade for something that runs on every page you read.

Manifest V3 throughout.

// The shadow DOM container stays isolated from the host page
const shadow = hostElement.attachShadow({ mode: 'closed' });
const tooltip = document.createElement('div');
shadow.appendChild(tooltip);
// Host page styles never bleed in; extension styles never bleed out

github.com/robertnowell/rabbitholes

Three translations instead of one: what I learned building konid

J Now — Tue, 05 May 2026 13:17:15 +0000

Literal translation tools give you one answer. That answer has no register, no cultural context, and no way to know whether you're being warm or clinical.

I was writing a message to my girlfriend in Farsi — something small, about missing her during the day — and every tool I tried handed me back a single string with no indication of whether it would land tender or transactional. Native speakers don't think in one-answer phrases. They pick from a register range depending on who they're talking to and what they want to convey.

So I built konid: it returns 3 options per query, ordered casual to formal, with the register of each one explained and a cultural note comparing them. It also plays audio pronunciation through your speakers via node-edge-tts — no external API key, no browser tab, just audio.

The MCP setup is one line:

claude mcp add konid-ai -- npx -y konid-ai

Works in Claude Code, Cursor, VS Code Copilot, Windsurf, Zed, JetBrains, and Claude Cowork. Also installs as a ChatGPT app via Developer mode at https://konid.fly.dev/mcp.

Supports 13+ languages: Mandarin, Japanese, Korean, Spanish, French, German, Portuguese, Italian, Russian, Arabic, Hindi, Farsi, and more.

The name is Farsi — كنيد means "do." MIT licensed.

github.com/robertnowell/konid-language-learning

Why MCP servers die six days after launch

J Now — Tue, 05 May 2026 11:12:42 +0000

The MCP ecosystem is moving fast enough that a useful server can go from "published" to "effectively abandoned" in a week — not because it broke, but because you posted once on launch day and never again. Most indie builders don't have a distribution habit. They have a shipping habit.

I built marketing-pipeline to handle the recurring work I kept skipping: rotating posts across channels, keeping directory listings current, showing up consistently without me thinking about it.

The mechanics: onboarding a project takes one command.

marketing onboard --name my-tool --repo owner/repo --kind mcp-server

That fetches the README, sends it to Claude, and writes problem, facts, and angles to projects.yml. From there, a daily GitHub Actions cron at 14:00 UTC picks the least-recently-used angle per project and drafts posts at per-channel length limits — 300 chars for Bluesky, 280 for X, 150–400 words for Dev.to and Hashnode.

The kind field does the routing. Tag something mcp-server and it targets MCP Registry, Smithery, Glama, and PulseMCP. Tag it claude-skill and it goes toward awesome-claude-code (the pipeline generates the payload; their rules require a human to submit via their GitHub issue form, so that step stays manual). Tag it browser-extension and it routes to Chrome Web Store, Firefox AMO, and Edge Add-ons.

The part I spent the most time on is pipeline/antislop.py — a hard-reject gate that runs before any post is published. It blocks specific tokens: excited, game-changer, unlock, empower, AI-powered, emoji, hashtags, exclamation points, rhetorical questions. Soft filtering wasn't enough; I needed something that would fail loudly rather than let a garbage post through at 2am.

Required credentials: Anthropic API key, plus Bluesky, Dev.to, and Hashnode tokens. Mastodon and Slack are optional.

If you've shipped an MCP server or Claude Code skill and the launch-day post was the last one, this is the part of the stack that was missing.

github.com/robertnowell/marketing-pipeline

Mapping 11 AI collaboration behaviors across your own Claude sessions

J Now — Mon, 04 May 2026 19:16:09 +0000

Anthropics February 2026 study classified 11 observable collaboration behaviors across 9,830 Claude conversations. I wanted to run the same classification on my own sessions — not to benchmark myself against other users, but to see which behaviors I was avoiding entirely.

The pattern I kept finding: heavy on Description (context-setting, explaining requirements), almost nothing on Delegation (trusting Claude to make structural decisions autonomously). I had optimized for speed at the exact same habits.

skill-tree pulls your Claude Code or Cowork session history, runs the same 11-behavior taxonomy from Dakan & Feller's 4D AI Fluency Framework, and returns a stable URL with your results. The classifier runs on Fly.io (~30–60 seconds end-to-end), and the visualization is stored on a volume so the URL persists.

The output includes a skill radar across three visible axes (Description, Discernment, Delegation — Diligence is the fourth axis but isn't recoverable from chat logs), one of seven archetype cards rendered as tarot cards with curated museum art, and a growth quest: a specific behavior from the 11 you haven't touched recently, surfaced as a prompt for your next session. The quest persists across sessions via a SessionStart hook.

The archetypes — Illuminator, Navigator, Alchemist, and four others — aren't just labels. Each maps to a specific behavioral signature across the three axes. You can see what the Illuminator card looks like rendered at skill-tree-ai.fly.dev/fixture/illuminator.

Install in Claude Code:

claude plugin marketplace add robertnowell/ai-fluency-skill-cards && claude plugin install skill-tree-ai@ai-fluency-skill-cards

Also works in Cowork via skill-tree-ai.zip, and as an MCP server (npm install skill-tree-ai) for Cursor, VS Code, or Windsurf.

github.com/robertnowell/skill-tree

Terminal themes optimize for syntax. Claude Code isn't syntax.

J Now — Mon, 04 May 2026 17:24:01 +0000

After a few weeks of heavy Claude Code sessions, I noticed the thing that was actually tiring wasn't the work — it was reading. Tool output, permission prompts, reasoning traces, explanations. Paragraphs. Most of my screen at any given moment is English prose at body size, not syntax-highlighted Python. Every terminal theme I tried was optimizing for the wrong workload.

So I built klein-blue: four Terminal.app themes tuned specifically for prose legibility in Claude Code, anchored to Yves Klein's IKB pigment.

The core design problem: pure IKB fails as readable text on dark ground. APCA scores it Lc -12 — effectively invisible. The fix was to split it across two ANSI slots. The plain blue slot gets pure IKB for decorative borders and highlights where legibility doesn't matter. The bright blue slot gets a lifted Klein-family blue (hex A8BEF0) for permission-prompt text that actually needs to be read. You keep the pigment; you don't go blind.

Contrast is enforced per semantic role using the APCA Lc metric, not WCAG ratios. WCAG was designed for static web content at display sizes; APCA is perceptually uniform and handles body text on dark backgrounds more honestly. The gates: body >= 90, subtle >= 75, muted >= 45, accent >= 60. The third variation, Klein Void Prot, is the only one where every accent slot clears strict gates — the others make deliberate tradeoffs for visual character.

The fourth slot Claude Code uses heavily is ansi:redBright — its claude-sand brand color. That slot became the differentiating axis between variations: neutralize it to let IKB dominate, or accept it as a second hero. Klein Void Sand & Sea takes the two-hero approach; Klein Void Gallery maximizes the void.

# Install
git clone https://github.com/robertnowell/klein-blue
cd klein-blue && ./install.sh
# Then in Claude Code: /theme -> dark-ansi
# (without dark-ansi, Claude Code ignores the ANSI palette entirely)

Built for macOS Terminal.app; ships as .terminal profile files with CommitMono and IBM Plex Mono depending on variation. Full rollback via restore.sh.

https://github.com/robertnowell/klein-blue

rabbitholes: inline Wikipedia for any word on any page

J Now — Mon, 04 May 2026 15:55:41 +0000

Reading a long-form piece on, say, the Peloponnesian War. Thucydides gets mentioned as a primary source. I half-know who he is — historian, Athenian, that's about it — but not enough to understand why the author is citing him specifically over Herodotus. Opening a new tab means I lose the sentence I was in. Skipping it means I read shallower than the text deserves.

rabbitholes is a Chrome extension that solves this with a shadow-DOM tooltip. Highlight any text, get an inline explanation from Claude next to your cursor. The host page is untouched — shadow DOM keeps the overlay isolated so it doesn't conflict with the site's styles or scripts.

The part I use most: every word in the explanation is itself clickable. Highlight "Thucydides," get an answer that mentions "the Peloponnesian War," click that phrase to go deeper. Each answer also surfaces two suggested rabbit-hole topics — the most interesting threads from where you currently are. A counter tracks how many hops you've taken; if you tunnel far enough you hit philosophy, and it generates a shareable trail of your path.

For cases where the base explanation isn't enough, a globe icon re-runs the query enriched with Brave Search results, with clickable source chips. A pencil icon opens a free-form follow-up that inherits the current context.

No analytics, no telemetry, no proxy server. Requests go directly from your browser to api.anthropic.com and api.search.brave.com. Your Anthropic API key lives in chrome.storage.sync, encrypted, never touches an intermediary.

Manifest V3 throughout.

github.com/robertnowell/rabbitholes