u/Best_Volume_3126

Markdown made sense when you were the one editing the file. You'd write a plan, Claude would suggest changes, you'd merge them by hand. The format served that loop.

That loop is mostly gone. Claude edits the files now. You read them, or you pass them to a verification agent, or you share them with someone who needs to approve the direction. Nobody's doing line edits in a text file.

Markdown still works at 30 lines. Past 100, most people stop reading. The format can't hold tables with real styling, can't embed diagrams that don't look like ASCII guesswork, can't let you interact with the content. It just sits there as text.

HTML doesn't have those limits. Claude can put real tabular data in a table with CSS, draw diagrams in SVG, add JavaScript-driven sliders so you can tune a parameter and see the result, build a mobile-responsive layout if the file needs to travel. There's almost no category of information that won't fit, and you can share it as a URL instead of an attachment.

The practical upgrade shows up fast in a few specific workflows.

Specs and planning. Instead of a 200-line markdown plan nobody reads, ask Claude Code to produce an HTML file with mockups, data flow diagrams, and annotated code snippets in one document. Pass that file into the next session as context. The verification agent reads it too and has far more to work with than a flat text spec.

A prompt that works:

>

Code review. Rendered diffs, severity-coded annotations, flowcharts of the logic you're trying to explain, all in one file you attach to the pull request. The default GitHub diff view doesn't do any of that.

>

Throwaway editors. This one takes a minute to see, but it's the most useful pattern. When you're working on something that's painful to describe in text, ask Claude to build you a single-purpose HTML interface for that exact thing. Drag-and-drop ticket triage, a form-based config editor with dependency warnings, a side-by-side prompt editor with live variable rendering. Always end it with an export button that outputs the result as text or JSON you can paste back into Claude Code.

>

The export button is the critical detail. Without it, the editor is a dead end. With it, it becomes a UI layer for your agent loop.

Context is the reason to use Claude Code specifically for this. Claude Code can read your file system, pull from connected Model Context Protocol servers like Slack or Linear, check your git history. An HTML report built from that context will have actual specifics in it, not placeholders.

One real tradeoff: HTML diffs are noisy. If your team reviews documentation in version control, HTML is harder to scan than markdown. For files that live in a repo and get reviewed in pull requests, markdown still wins. For files that get read, shared, or acted on, HTML is the better format.

The frontend design plugin helps Claude produce cleaner, more consistent HTML output. If you want it to match your product's visual style, point Claude at your codebase and ask it to generate a design system reference file first, then use that as a reference for subsequent HTML outputs.

You don't need a skill or a preset for any of this. Ask Claude to make an HTML file and describe what it should contain. The format will handle the rest.

I didn’t expect TTC for another baby to feel emotionally this complicated. On one hand, I feel incredibly grateful to already have a child. On the other hand, every unsuccessful cycle still hurts more than I want to admit, and then I immediately feel guilty for even being upset about it.

I also think I underestimated how hard it is to TTC while parenting at the same time. Between exhaustion, schedules, interrupted sleep, and just constantly being needed by someone else, it feels very different from TTC the first time around. Some days I’m calm about it, and other days I find myself spiraling over timing, symptoms, and whether something is wrong because it isn’t happening as quickly this time... this version of TTC feels emotionally very different than I expected.

Here's Karpathy's Claude complaints into 4 rules, put them in a single CLAUDE.md. The rules worked. Across 30 codebases over 6 weeks, mistake rates dropped from 41% to 11%.

The 4 rules were written for single-shot, one-codebase autocomplete sessions. They don't cover agent loops, multi-step tasks, or silent failures. Below are 8 rules that do.

The original 4

## Rule 1 — Think Before Coding
State assumptions explicitly. Ask rather than guess.
Push back when a simpler approach exists. Stop when confused.

## Rule 2 — Simplicity First
Minimum code that solves the problem. Nothing speculative.
No abstractions for single-use code.

## Rule 3 — Surgical Changes
Touch only what you must. Don't improve adjacent code.
Match existing style. Don't refactor what isn't broken.

## Rule 4 — Goal-Driven Execution
Define success criteria. Loop until verified.
Strong success criteria let Claude loop independently.

The 8 rules I added

Rule 5. Claude called to decide whether to retry on 503 worked for two weeks, then started flaking. The model read the request body as context for the retry decision. The policy became random.

## Rule 5 — Use the model only for judgment calls
Use for: classification, drafting, summarization, extraction.
Do NOT use for: routing, retries, status-code handling, deterministic transforms.
If code can answer, code answers.

Rule 6. A debugging session ran 90 minutes on the same 8KB error. By message 40, Claude was re-suggesting fixes rejected 40 messages earlier.

## Rule 6 — Token budgets are not advisory
Per-task: 4,000 tokens. Per-session: 30,000 tokens.
If approaching budget, summarize and start fresh.
Surface the breach. Do not silently overrun.

Rule 7. A codebase had two error-handling patterns. Claude blended them. Errors got swallowed twice.

## Rule 7 — Surface conflicts, don't average them
If two patterns contradict, pick one (more recent / more tested).
Explain why. Flag the other for cleanup.
Don't blend conflicting patterns.

Rule 8. Claude added a function next to an identical one it hadn't read. The new one took precedence via import order. The original had been source of truth for 6 months.

## Rule 8 — Read before you write
Before adding code, read exports, immediate callers, shared utilities.
If unsure why existing code is structured a certain way, ask.

Rule 9. Claude wrote 12 tests for an auth function, all passed, auth was broken in production. The tests verified the function returned something. The function returned a constant.

## Rule 9 — Tests verify intent, not just behavior
Tests must encode WHY behavior matters, not just WHAT it does.
A test that can't fail when business logic changes is wrong.

Rule 10. A 6-step refactor went wrong on step 4. Claude completed steps 5 and 6 on top of the broken state before I noticed.

## Rule 10 — Checkpoint after every significant step
Summarize what was done, what's verified, what's left.
Don't continue from a state you can't describe back.
If you lose track, stop and restate.

Rule 11. Claude introduced React hooks into a class-component codebase. They worked. They broke the testing patterns, which assumed componentDidMount.

## Rule 11 — Match the codebase's conventions, even if you disagree
Conformance > taste inside the codebase.
If you think a convention is harmful, surface it. Don't fork it silently.

Rule 12. Claude reported a database migration "completed successfully." It had skipped 14% of records on constraint violations, logged but not surfaced. Found 11 days later.

## Rule 12 — Fail loud
"Completed" is wrong if anything was skipped silently.
"Tests pass" is wrong if any were skipped.
Default to surfacing uncertainty, not hiding it.

Full file (copy-paste ready)

# CLAUDE.md — 12-rule template

These rules apply to every task in this project unless explicitly overridden.
Bias: caution over speed on non-trivial work.

## Rule 1 — Think Before Coding
State assumptions explicitly. Ask rather than guess.
Push back when a simpler approach exists. Stop when confused.

## Rule 2 — Simplicity First
Minimum code that solves the problem. Nothing speculative.
No abstractions for single-use code.

## Rule 3 — Surgical Changes
Touch only what you must. Don't improve adjacent code.
Match existing style. Don't refactor what isn't broken.

## Rule 4 — Goal-Driven Execution
Define success criteria. Loop until verified.
Strong success criteria let Claude loop independently.

## Rule 5 — Use the model only for judgment calls
Use for: classification, drafting, summarization, extraction.
Do NOT use for: routing, retries, deterministic transforms.
If code can answer, code answers.

## Rule 6 — Token budgets are not advisory
Per-task: 4,000 tokens. Per-session: 30,000 tokens.
If approaching budget, summarize and start fresh.
Surface the breach. Do not silently overrun.

## Rule 7 — Surface conflicts, don't average them
If two patterns contradict, pick one (more recent / more tested).
Explain why. Flag the other for cleanup.

## Rule 8 — Read before you write
Before adding code, read exports, immediate callers, shared utilities.
If unsure why existing code is structured a certain way, ask.

## Rule 9 — Tests verify intent, not just behavior
Tests must encode WHY behavior matters, not just WHAT it does.
A test that can't fail when business logic changes is wrong.

## Rule 10 — Checkpoint after every significant step
Summarize what was done, what's verified, what's left.
Don't continue from a state you can't describe back.

## Rule 11 — Match the codebase's conventions, even if you disagree
Conformance > taste inside the codebase.
If you think a convention is harmful, surface it. Don't fork silently.

## Rule 12 — Fail loud
"Completed" is wrong if anything was skipped silently.
"Tests pass" is wrong if any were skipped.
Default to surfacing uncertainty, not hiding it.

Save at repo root. Add project-specific rules below. Hard ceiling at 200 lines total: compliance drops past it. Going from 4 rules to 12 moves compliance from 78% to 76% and cuts mistake rate from 11% to 3%.

A solo dev won the Anthropic hackathon by shipping a product in eight hours with Claude Code. Prize: $15,000. He open-sourced the repo and it sits at 153,000+ stars on GitHub.

The repo is Everything Claude Code (ECC). Claude Code with 38 specialized agents, 156 skills, 72 commands, and a security scanner with 1,282 tests.

Install selectively

# Plugin install
/plugin marketplace add affaan-m/everything-claude-code
/plugin install everything-claude-code@everything-claude-code

# Or pick what you need
ecc install --profile developer \
  --with lang:typescript \
  --with agent:security-reviewer \
  --without skill:continuous-learning

Loading all 156 skills wastes context. Pick your stack, drop the rest.

Agents that do one job

planner             → breaks down task, delegates to specialists
security-reviewer   → scans for vulnerabilities pre-ship
typescript-reviewer → catches TS antipatterns
code-reviewer       → 5 parallel checks
debugger            → root-cause analysis

Coverage spans 12 language ecosystems. The planner agent handles orchestration: hand it a ticket, it decomposes the work and routes to specialists.

Skills load on demand

/plan          → structured task planning
/tdd           → test-driven workflow
/security-scan → AgentShield audit
/quality-gate  → ship-readiness check
/simplify      → refactor for readability

Stack-specific ones too: nextjs-turbopack, bun-runtime, pytorch-patterns, mcp-server-patterns.

AgentShield

This is the part most people skip and where ECC pays for itself.

# Quick scan, no install
npx ecc-agentshield scan

# Auto-fix safe issues
npx ecc-agentshield scan --fix

# Three Opus 4.6 agents in red-team pipeline
npx ecc-agentshield scan --opus --stream

The --opus flag runs three Claude Opus 4.6 agents:

Attacker  → looks for exploit chains
Defender  → evaluates defenses
Auditor   → synthesizes a prioritized risk report

What gets scanned:

CLAUDE.md     → hardcoded secrets, injection vectors
settings.json → misconfigured permissions
MCP configs   → server risks (25+ known CVEs)
Hooks         → injection analysis
Agents        → prompt injection, privilege escalation
Skills        → supply chain verification

Sample output:

Grade: B+
Critical: 0 | High: 2 | Medium: 5 | Low: 3

❌ HIGH: Hardcoded API key in CLAUDE.md:15
   Fix: Move to environment variable

Drops into continuous integration so any pull request changing an agent config gets audited.

The learning layer

Stock Claude Code starts each session blank. ECC's continuous learning watches your sessions and builds patterns:

Session 1:  you fix an async error pattern    (confidence: 0.3)
Session 5:  same pattern, refined             (confidence: 0.6)
Session 10: stable, applied automatically     (confidence: 0.9)

A knowledge layer that persists across sessions, sharpens with use. After two or three weeks, Claude writes in your conventions instead of generic large language model defaults.

Three repos that close ECC's gaps

claude-mem for cross-session memory (github.com/thedotmack/claude-mem). Five lifecycle hooks, SQLite storage, web viewer at localhost:37777.

/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

Superpowers for forced planning (github.com/obra/superpowers). ECC's agents will write 400 lines without a plan. Superpowers makes them think first.

/plugin marketplace add obra/superpowers
/plugin install superpowers

CLAUDE.md rules for predictable agent behavior. All 38 agents read the file. Drop in:

- Run tests before marking task complete
- Never create files outside the project directory
- Ask before deleting any file
- Explain reasoning before writing code
- If unsure, ask. Don't guess.

Easy setup

# 1. Install ECC for your stack
/plugin install everything-claude-code@everything-claude-code

# 2. Memory
/plugin install claude-mem

# 3. Planning discipline
/plugin install superpowers

# 4. Security scan
npx ecc-agentshield scan --fix

# 5. Drop behavior rules into CLAUDE.md

A Cowork plugin is a folder with a specific structure. Get the structure right and you have something that behaves like a hired role instead of a chat session that occasionally helps with files.

Here's the layout:

my-plugin/
├── .claude-plugin/
│   └── plugin.json        ← Identity: name, role, description
├── skills/
│   └── primary-task/
│       └── SKILL.md        ← The workflow: step-by-step process
├── commands/
│   └── run-task.md         ← Slash commands: /prefix:command
├── references/
│   └── templates.md        ← Reference materials: templates, benchmarks, examples
├── global-instructions.md  ← Standing orders: personality, preferences, defaults
└── folder-instructions.md  ← Project-specific context

Each file does one job. plugin.json registers the plugin and tells Cowork when to wake it up. SKILL.md holds the workflow. The commands/ folder gives you slash triggers. References hold templates and benchmarks. Global instructions set standing behavior. Folder instructions handle per-project context.

Most people write the SKILL.md and skip the rest, which is why their plugin behaves like a smart prompt rather than a role.

Step 1: Map the role before you write anything

Run this in Claude before you touch a file:

>"Research the complete professional workflow for a [ROLE] in [INDUSTRY]. Include: the step-by-step process they follow, tools and data sources they use, key metrics and decision criteria, common output formats, and expert-level edge cases and pitfalls. Be comprehensive — I am building an automated workflow from this."

Then write down your version of the same workflow. The shortcuts you take, the checks you run, the failure modes you watch for. The plugin gets built from your process, not the generic one.

Step 2: Write the SKILL.md

Every other file in the plugin orbits this one. The frontmatter description decides whether the skill activates at all. A vague description never fires, and a broad one fires on everything, so you want the trigger phrases tight and the negative boundaries explicit.

---
name: [skill-name]
description: [When should this activate? Be aggressive with trigger phrases. 
"Use this skill when the user says: [list 5-7 phrases]. 
Do NOT use for: [list things that sound similar but are different]."]
---

# Overview
[One paragraph: what this skill does and what it produces]

## Process
[Numbered steps. Every step is specific, testable, and unambiguous.
Not "analyze the data" but "compare current period to previous period
and calculate the percentage change for each metric."]

1. [Step with specific instruction]
2. [Step with specific instruction]
3. [Step with specific instruction]
...

## Output Format
[Exactly what the deliverable looks like]
- Title format
- Section headers in order
- Length constraints
- Formatting requirements

## Rules
[Your non-negotiable quality standards]
- [Rule 1]
- [Rule 2]
- [Rule 3]

## Edge Cases
[What to do when things are not straightforward]
- If [situation]: [specific action]
- If [situation]: [specific action]

## Quality Checklist
[Run this before delivering any output]
- [ ] [Check 1]
- [ ] [Check 2]
- [ ] [Check 3]

Each process step has to be testable. "Analyze the data" fails that test. "Compare the current period to the previous period and calculate the percentage change for every metric" passes.

Step 3: Wire up the supporting files

plugin.json:

{
  "name": "my-ai-employee",
  "description": "A [ROLE] that [WHAT IT DOES] for [WHO]",
  "version": "1.0"
}

A slash command in commands/run-task.md:

# /employee:run

Execute the [primary-task] skill on the data in the current folder.

Steps:
1. Read all relevant files in the working directory
2. Execute the skill following every step in SKILL.md
3. Run the quality checklist before delivering
4. Save the output as [format] to the current folder
5. Provide a brief summary of what was produced

Global instructions in global-instructions.md:

You are a [ROLE] with [YEARS] of experience in [INDUSTRY].

Standing Orders:
- Lead with the recommendation, explain after
- Always use specific numbers, never vague descriptions
- If data is missing or ambiguous, flag it — never guess
- Default output format: [YOUR PREFERENCE]
- Communication style: [DIRECT/CONVERSATIONAL/FORMAL]
- When in doubt, ask rather than assume

References go in references/. Templates, benchmarks, scoring rubrics, sample outputs ranked good to bad. Whatever the plugin can produce at its best is bounded by the quality of the material in this folder.

Step 4: Install and run it on real work

Drop the plugin into your Cowork environment and verify it loaded:

>"I have a plugin folder at [PATH]. Verify the structure is valid — check plugin.json, SKILL.md frontmatter, and command files. Install it and run a quick test with the simplest slash command."

Then run it on real inputs from your queue, five times. After each run, check whether it followed every step, hit the format spec, and respected the rules. The first three runs will surface every gap in your SKILL.md. Patch the file and rerun.

The refinement loop is where the plugin earns its keep. Edit the skill every time the output misses, add a rule when something gets guessed wrong, drop a good-versus-bad example into references when format drifts. Fifteen minutes a week of this, and by week eight the plugin is producing outputs you ship without edits, which is not where you were at week one.

Step 5: Stack capabilities

Once one skill runs cleanly, add another skill folder under skills/. Chain skills inside a single slash command so research, analysis, and report writing fire from one trigger. Schedule the command with a cron-style runner so the weekly report writes itself every Friday. For heavy workloads, a parent skill can dispatch sub-agents that process files in parallel instead of sequentially.

The instructions improve when you edit them, and the instructions are sitting in a folder you own.

Most multi-agent code I read should have been one tool call. The orchestration is doing nothing the model couldn't do alone, and now there are five places a frontier model can lose the thread instead of one.

So I work up the ladder. Four patterns, picked by how much control the main agent needs over the subagent's lifecycle. I default to the smallest one that fits.

1. Inline Tool: subagent as a function call

The main agent calls call_agent and gets a result back. From the calling model's view, it looks identical to read_file. Lifecycle is invisible.

[
  { "role": "user", "content": "Review PR #42 for security issues" },
  { "role": "assistant", "tool_calls": [
    { "name": "call_agent", "arguments": { "task": "Review PR #42 for security issues. Focus on auth changes.", "agent": "security-reviewer", "tools": ["read_file", "search_code"] } }
  ]},
  { "role": "tool", "name": "call_agent", "content": "Found 2 issues: 1) Auth token not validated in /api/users endpoint. 2) Session cookie missing HttpOnly flag in login handler." },
  { "role": "assistant", "content": "The review found 2 security issues..." }
]

Sync mode blocks until the subagent finishes. Async returns an ID and the result lands later as an injected user message:

[
  { "role": "user", "content": "Review PR #42 and also check the CI logs" },
  { "role": "assistant", "tool_calls": [
    { "name": "call_agent", "arguments": { "task": "Review PR #42 for security issues", "agent": "security-reviewer", "background": true } },
    { "name": "read_file", "arguments": { "path": "ci/logs/latest.txt" } }
  ]},
  { "role": "tool", "name": "call_agent", "content": "agent_id: agent-x1. Running in background." },
  { "role": "tool", "name": "read_file", "content": "Build passed. 142 tests green." },
  { "role": "assistant", "content": "CI looks clean. Waiting for the security review..." },
  { "role": "user", "content": "<notification agent_id='agent-x1' status='completed'>Found 2 issues: ...</notification>" },
  { "role": "assistant", "content": "The security review found 2 issues..." }
]

This handles most of what people reach for subagents to do. Code review, file analysis, research lookups, test generation. Works on cheaper models too. The catch is you can't course-correct mid-task. If the subagent went sideways, you find out when the result comes home.

2. Fan-Out: spawn now, wait later

Two tools instead of one. spawn_agent returns an identifier immediately. wait_agent blocks until something finishes. The main model decides the gap between them.

[
  { "role": "user", "content": "Refactor the auth module and update all related tests" },
  { "role": "assistant", "tool_calls": [
    { "name": "spawn_agent", "arguments": { "task": "Refactor the auth module to use JWT tokens", "agent": "backend-engineer" } },
    { "name": "spawn_agent", "arguments": { "task": "Update all auth-related tests for the new JWT flow", "agent": "test-writer" } },
    { "name": "read_file", "arguments": { "path": "docs/auth-spec.md" } }
  ]},
  { "role": "tool", "name": "spawn_agent", "content": "Spawned agent-a (backend-engineer). Running." },
  { "role": "tool", "name": "spawn_agent", "content": "Spawned agent-b (test-writer). Running." },
  { "role": "tool", "name": "read_file", "content": "# Auth Spec\nJWT tokens with RS256..." },
  { "role": "assistant", "content": "I've kicked off both tasks. The auth spec confirms we should use RS256." },
  { "role": "assistant", "tool_calls": [{ "name": "wait_agent", "arguments": { "timeout": 300 } }]},
  { "role": "tool", "name": "wait_agent", "content": "2 agents completed:\n- agent-a: Refactored 3 files (auth.ts, middleware.ts, config.ts)\n- agent-b: Updated 12 tests, all passing" },
  { "role": "assistant", "content": "Both tasks are done. The auth module now uses JWT..." }
]

The whole point is the work the main agent does between spawn and wait. A model that fires wait_agent on the next turn after every spawn has built Pattern 1 with extra steps and gotten nothing for it. I use this when I have two or three independent tracks that don't depend on each other's intermediate output.

3. Agent Pool

Subagents are stateful. Spawn them once, send messages, get replies, send more. They keep their conversation history. Tools: spawn_agent, send_message, wait_agent, list_agents, kill_agent.

Worth it when you have a real handoff. Researcher gathers, writer drafts, researcher fact-checks the draft against its earlier sources. Pattern 2 can't do that because the researcher loses its context after the first wait.

The main agent's job gets harder. It tracks who has what context and remembers to call kill_agent when an agent is done. Below frontier capability, models leak agents around three or four. I cap myself there.

4. Teams: agents talk to each other

Same tools as Pattern 3, plus every subagent gets send_message in its own toolset and can address its peers. The main agent sets up the team, kicks off a planner, and steps back. Coordination happens between the agents.

[
  { "role": "user", "content": "Build feature X" },

  { "role": "assistant", "tool_calls": [
    { "name": "spawn_agent", "arguments": { "role": "planner", "tools": ["read_file", "search_code", "send_message"] } },
    { "name": "spawn_agent", "arguments": { "role": "implementer", "tools": ["read_file", "write_file", "run_command", "send_message"] } },
    { "name": "spawn_agent", "arguments": { "role": "reviewer", "tools": ["read_file", "search_code", "send_message"] } }
  ]},
  { "role": "tool", "name": "spawn_agent", "content": "Spawned agent-p (planner)" },
  { "role": "tool", "name": "spawn_agent", "content": "Spawned agent-i (implementer)" },
  { "role": "tool", "name": "spawn_agent", "content": "Spawned agent-v (reviewer)" },

  { "role": "assistant", "tool_calls": [{ "name": "send_message", "arguments": { "to": "agent-p", "message": "Plan and coordinate feature X. Your teammates: agent-i (implementer), agent-v (reviewer). Message them directly. Report back to me when done." } }]},
  { "role": "tool", "name": "send_message", "content": "Delivered to agent-p" },

  { "role": "assistant", "tool_calls": [{ "name": "wait_agent", "arguments": { "timeout": 60 } }]},
  { "role": "tool", "name": "wait_agent", "content": "Timed out. No agents responded." },

  { "role": "assistant", "tool_calls": [{ "name": "list_agents", "arguments": {} }]},
  { "role": "tool", "name": "list_agents", "content": "agent-p: running, agent-i: running, agent-v: idle" },

  { "role": "assistant", "tool_calls": [{ "name": "wait_agent", "arguments": { "timeout": 120 } }]},
  { "role": "tool", "name": "wait_agent", "content": "agent-p responded: Feature X complete. 3 files changed, all tests passing. Summary: ..." },

  { "role": "assistant", "content": "Feature X is built. Here's what was done..." }
]

Same tools as Pattern 3, plus every subagent gets send_message and can address its peers. Main agent sets up the team, kicks off a planner, steps back.

This is where I get nervous. Every team member needs to be smart enough to decide when to message a peer and when to call it done. Cycles happen, A waits on B, B waits on A. Two agents edit the same file. Tracing a failure across four message logs is brutal compared to one. I reach here only when the coordination itself is the hard part, not the underlying work.

How I pick

Default to Pattern 1. Two independent jobs running while the main agent does something useful goes to Pattern 2. Output handed back and forth between specialists goes to Pattern 3. Coordination too thick to track step-by-step goes to Pattern 4, and you pay for it in debugging hours. Every layer up adds another place to lose state.

I have noticed that Self-improving agents have a hoarding problem. Every skill the agent writes sticks around forever. The catalog grows but the agent loads more of it on every prompt, and instead of solving the new problem it rereads its own old work.

Nous Research shipped Hermes Curator on May 1 to fix this. It's a background maintenance pass for agent-created skills, in Hermes Agent v0.12.0.

How it works

Curator runs only when the agent is idle. Roughly once a week, after at least two hours of no activity, it runs a single review pass in a separate process.

The mechanical half checks last-used timestamps. Untouched for 30 days, the skill goes stale. Untouched for 90 days, it moves to an archive folder. Nothing is deleted. Anything comes back with one command.

The second half uses a cheaper auxiliary model. It reads the skills the agent has written, finds overlap and drift, and proposes merges, patches, or archival. Because it runs on a separate slot, you can point it at something like Gemini Flash instead of paying main-model rates for housekeeping.

All thresholds live in config.yaml under curator:.

Guardrails

Curator only touches skills the agent wrote or you wrote by hand. Skills that shipped with Hermes or came from the hub are off-limits.

Pinned skills are invisible to the demotion clock and the review model. Even the agent's own editing tools refuse to modify a pinned skill. That's the lever for protecting anything you depend on.

Every counter and timestamp lives in one sidecar file in the skills folder. Plain text. No hidden database.

The CLI

hermes curator status              # last run, counts, pinned list, LRU top 5
hermes curator run                 # trigger a review now (background by default)
hermes curator run --sync          # same, but block until the LLM pass finishes
hermes curator pause               # stop runs until resumed
hermes curator resume
hermes curator pin <skill>         # never auto-transition this skill
hermes curator unpin <skill>
hermes curator restore <skill>     # move an archived skill back to active

hermes curator status lists the five least-recently-used skills. Quick way to see what's about to go stale. Pin anything on that list you want to keep.

Why this matters

At one new skill per day, the catalog hits 30 in a month and 365 by year one. With Curator's review pass merging near-duplicates, only about 3 unique skills survive per month. Roughly 36 a year instead of 365.

Most agent-created skills are not unique. The agent writes fix-a-bug five different ways across five different days, none of them aware the others exist.

Without pruning, the token bill climbs because every prompt pays to read a bigger directory. And the reasoning gets worse because five near-duplicates all match the same query and the model has no signal for which to pick. The agent gets slower and dumber as the catalog grows.

Memory and skills are different layers

Easy to call Curator memory management. It isn't.

Memory is what the agent knows. Facts, past conversations, decisions. Tools like mem0 manage that layer.

Skills are procedural. How to refactor a file, how to query a specific application programming interface. Curator manages that layer.

They don't compete. Memory consolidation handles what the agent knows. Curator handles how the agent works. Building one doesn't replace the other.

If you're building agents that save their own skills, a cleanup pass stops being optional fast. Self-improving agents need self-pruning systems.

OpenClaw hit 346k GitHub stars surpassed React's ten-year total in under five months, and pulled 38 million monthly visitors with 500,000 running instances. .

Then Hermes Agent shipped. By March it was on GitHub Trending. By April it had overtaken OpenClaw in Google search interest in the agent category.

Here's the actual technical comparison.

What is OpenClaw & Hermes Agents

OpenClaw is a personal AI agent that runs locally and hands you a blank canvas. You connect messaging channels, write or install skills, and route tasks to whichever model fits. It runs Anthropic Claude (Opus, Sonnet), OpenAI GPT-5.5, Kimi K2.6, Grok, or anything you point at it through Ollama. It hooks into Claude Code for heavy coding work. The core idea: a persistent agent on your hardware that knows your full setup and runs continuously across every channel you use.

Hermes Agent is built by Nous Research and runs locally too, but the philosophy inverts. Instead of you writing skills, Hermes distills every completed task into a reusable skill on its own. It ships with 40+ tools wired up out of the box and is built around cost-efficiency as a design constraint, not an afterthought.

Both put a capable agent on your hardware. They disagree on how you should get there.

Where OpenClaw wins

Skills ecosystem. ClawHub has 44,000+ skills, all run through a security review before listing. Hermes is building toward this but isn't close yet.

Model flexibility. You can run an Opus brain for planning, Sonnet workers for execution, GPT-5.5 for specific tasks, and a local Ollama model for cheap throughput, all in the same agent. Hermes is more constrained.

Channel integrations. Telegram, Discord, WhatsApp, iMessage, and Slack work out of the box. If your agent's job is to live across your messaging surface, this is the point that decides it.

Multi-agent architecture. Sub-agents with different roles, different models, and different scopes are native. You don't bolt this on, it's how the system is shaped.

Community gravity. Bigger user base, more documented failures, more contributors after steipete (the original creator) joined OpenAI and pulled resources in. When you hit a problem at 1am, someone has already filed the issue.

Where Hermes wins

The self-improving loop. This is the part of Hermes that's actually different, not just packaged differently. Every completed task gets extracted into a reusable skill automatically. OpenClaw has memory and skills, but you write them. Hermes writes them by running. That compounds.

Token costs. One founder reported $130 over 5 days on OpenClaw vs $10 on Hermes for comparable tasks. The number depends heavily on model choice on each platform, but Hermes is built around cost-efficiency at the architecture level, not as a configuration you opt into.

Time to first useful output. OpenClaw's blank canvas is powerful and slow. Hermes ships with Notes, iMessage, browser control, image generation, scheduled tasks, and Obsidian integration already wired up. Most people who buy OpenClaw and stop using it stopped during the configuration weeks. Hermes removes that wall.

Task isolation. Hermes runs tasks in isolated environments. For client data, financial workflows, or anything you don't want bleeding across contexts, that isolation model is a real security gain, not a marketing line.

comparison

OpenClaw:

• High setup complexity, you build the agent
• Higher token costs, depending on models used
• 44,000+ skills on ClawHub
• Manual self-improvement, you write or install skills
• Extensive channel integrations (Telegram, Discord, WhatsApp, iMessage, Slack)
• Any model: Anthropic, OpenAI, Kimi, Grok, local via Ollama
• Native multi-agent
• Largest community and docs

Hermes:

• Low setup complexity, install and go
• Roughly 90% lower token costs in reported real-world use
• 40+ tools built in
• Self-improving loop, learns your workflows
• Limited channel integrations
• Multi-agent still in development
• Growing fast

Pick OpenClaw if

You want maximum customisation and you'll do the maintenance. You need deep messaging channel integrations. You're running multiple specialised agents at once. You want to mix model providers per task. You're already invested in the skills ecosystem. You like building infrastructure.

Pick Hermes if

You want something that works on install. Token costs are a real constraint. You want the agent to learn your workflows on its own. You've been stalling on an agent setup because the complexity scared you off. You need task isolation for sensitive work.

Cowork is now generally available on macOS and Windows, with enterprise features, a Zoom connector, and plugin support that landed in the last couple of months. None of it helps if Claude starts the session knowing nothing about you.

Here's the setup I run for myself and for clients.

1. Connect your tools first

Open Claude Desktop, go to connectors, wire up what you actually use:

• Google Workspace (Drive, Gmail, Calendar). Non-negotiable. Most of your business context lives here.
• Slack or Teams.
• Whatever runs your projects: Notion, Asana, Linear, Monday.
• Zoom, added April 2026, which pulls meeting context and recordings.

This goes first because the next step is faster when Claude can read your existing docs.

2. Build three context files

Context files load every session. They're how Claude knows who you are without you re-explaining it.

about-me.md covers what you do in one sentence, what you're running now, who your customers are, the tools you use daily, and the key people Claude should know about. Point Claude at your Drive and ask it to draft this from existing bios and about pages. Edit what it gets wrong.

voice.md is what stops Claude sounding like a robot. Communication style, words you refuse to use, how your tone shifts by context (client email vs team Slack vs social post), and two or three samples of writing that sounds like you. Paste real samples. A good email, a post that performed. Claude reverse-engineers patterns from examples better than from descriptions.

preferences.md is how you want Claude to work. Ask clarifying questions or just execute. Output format defaults. How detailed first drafts should be. Hard rules like "never use em dashes" or "keep responses under 300 words unless I ask for more."

Save all three in one folder. Select it at the start of every session.

3. Set global instructions

Global instructions run before you pick a folder. Condense the highlights from your three context files into roughly 800 words:

• Who I am (two or three sentences)
• How I work
• Output defaults by task type (emails get bullets, content gets paragraphs, research gets tables)
• Voice, top three or four characteristics
• What I'm working on right now
• Rules (always X, never Y)

Claude Desktop, Settings, Cowork, Edit next to Global Instructions, paste, save.

4. Install three to five skills

Look at your last week. What did you do more than once that felt repetitive? Start there.

Open plugin search, filter by keyword (content creation, sales, research, meeting prep), install three to five. Skip the twenty-skill loadout. You won't use most of them, and you can add more when you hit friction.

Custom skills are an option if nothing fits.

5. Create your first scheduled task

Scheduled tasks run on a schedule you set, no prompting required. Three good starters:

• Morning briefing, weekdays at 8 AM. Inbox triage, today's calendar, top three priorities.
• Weekly recap, Fridays at 4 PM. Completed tasks, overdue items, key wins.
• Meeting prep, 30 minutes before any call. Attendee context, prior communication, three talking points.

Specificity is what separates useful from noise. "Summarize my inbox" produces nothing you'll read. "Check Gmail for unread messages from clients, flag anything mentioning a deadline or needing a response today, list by priority" produces something you act on.

6. Calibrate during week one

Week one will not be clean. The briefing misses things. The voice file won't catch every nuance. Tasks need tuning. That's the work.

Every time Claude misses, tell it where. "Tone was too formal, match the sample in voice.md." "Briefing's too long, cap it at five bullets."

By end of week one, expect two or three small edits to your context files, a tighter global instructions block, tasks tuned to your rhythm. By week two it should feel like Claude has been working with you for months.

If your crown looks stubborn while your hairline and mid‑scalp are already improving, that is not bad luck or poor grafts; it is the biology and blood supply pattern of the crown doing exactly what it always does. Clinics routinely expect crown results to show fully only around 12–15 months, versus roughly 10–12 months for the frontal zone, so a “late” crown is actually the normal timeline, not an exception.

Why the crown grows slower than the front

The crown has relatively lower blood circulation compared to the frontal scalp, so newly implanted follicles there take longer to stabilise, re‑enter anagen, and thicken in calibre. That slower vascular support is the main reason the same technique and the same graft quality can look “ahead” in the hairline at Month 8–10 while the crown still appears behind, only catching up closer to the 1‑year‑plus mark. On top of this, crown patterns often need more grafts spread over a whorl, so early growth is diluted over a larger spiral area and only feels dense once enough follicles have thickened by Months 12–15.

What a normal delayed crown timeline actually looks like

For the front, visible new growth begins around Month 4 with approximately 30–40 percent of final density visible, then climbs to about 40–50 percent by Month 5, around 60 percent by Month 6, roughly 70 percent by Month 7, and close to 100 percent of the planned result by Months 10–12. The crown follows the same biological rules but on a lag: it often stays underwhelming through Month 6–8, starts looking meaningfully better closer to Month 9–10, and is only considered “final” in the 12–15 month window. So when you look at your Month 8 photos and feel “front is good, crown is a fail,” you are usually comparing a zone that is near its planned deadline with a zone that still has several scheduled months left on the clock.