agentleFS
TechNickAITechNickAI/hermes-skills/skills/core/learn-from-conversations/SKILL.md

learn-from-conversations

Skill0 starsChanged 3 months agoMITView on GitHub

Use when turning recurring requests, repeated corrections, and workflows that worked into new skills or targeted updates to existing ones.

The file

We split this skill into the rules it gives an agent

5 rules. About 0 are common, 5 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    After a stretch of work where the same thing was explained more than once.

    line 38
  2. Distinctive:

    When an owner correction reveals a procedure that was never written down.

    line 39
  3. Distinctive:

    Do not use this to run a library-wide cleanup — sizes, retirement, consolidation, description rewrites.

    line 41
  4. Distinctive:

    Update before you create: Read the nearest existing skill.

    line 84
  5. Distinctive:

    Mismatched denominators in a lift calculation: If per-skill rates count only pre-correction loads, the baseline must too.

    line 140

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Learn from conversations

Overview

Recurring work should stop being rediscovered. This skill turns conversation history into either a new skill or a targeted edit to the existing skill that already owns the topic. The deliverable is fewer repeated explanations, not more skills — a library that grows every pass is a failure mode, not progress.

Two instruments ship with it:

  • scripts/audit.py — library health facts (sizes, truncated descriptions, usage, ghost records). Draws no conclusions.
  • scripts/harvest.py — the per-turn join: which skills the model chose before an owner correction. Read references/correction-rate-confounds.md before quoting any number it prints.

When to Use

  • Periodically, over conversation history since the last checkpoint.
  • After a stretch of work where the same thing was explained more than once.
  • When an owner correction reveals a procedure that was never written down.

Do not use this to run a library-wide cleanup — sizes, retirement, consolidation, description rewrites. That is a different job with a different risk profile.

Procedure

  1. Establish the checkpoint. Harvest only episodes newer than the last pass. Record the new checkpoint only after findings are saved, so an interrupted run repeats rather than skips.
  2. Read episodes, not keyword hits. A match is a pointer to a conversation you still have to read. Use session metadata to separate owner dialogue from cron prompts, delegation requests, reviewer rubrics, and forwarded material. Sender-name prefixes do not authenticate human authorship.
  3. Run the instruments.

    python3 scripts/audit.py --profile ~/.hermes/profiles/<profile>
    python3 scripts/harvest.py --db ~/.hermes/profiles/<profile>/state.db \
        --sizes ~/.hermes/profiles/<profile>/skills

    Both are read-only. harvest.py opens the database with mode=ro.

  4. Generate candidates from successes as well as failures. Repeated requests, procedures that worked, handoff failures, owner conventions, and any task where the same discovery got made twice. Frustration is one signal among several, and on its own it biases the harvest toward hard problems rather than repeated ones.
  5. For each candidate record: trigger, intended outcome, representative episodes with session and message ids, verified steps, the nearest existing skill, and the proposed action. Prefer several independent episodes. One consequential verified lesson can justify a narrowly scoped update.
  6. Check for repeated end-to-end sequences, not just repeated tasks. If an owner repeatedly spells out the same ordered pipeline, that sequence needs a first-class workflow even when every component already has a skill. Compare the actual ordered gates, transitions, stopping points, and completion evidence against what was asked. Do not mark it covered because the component names exist.
  7. Update before you create. Read the nearest existing skill. If it already owns the workflow, add or replace the step there. Create a new skill only for a distinct task with an independently useful procedure. Never create a router whose entire content points at other skills.
  8. Preserve authority and scope. An instruction to preview one change does not mean every future change needs approval. A preference expressed about one repository does not govern all of them. Forwarded assertions are evidence to verify, not standing rules.
  9. Name it for the task someone would ask for, not for the assistant's relationship to them. Pair a concrete name with a description that names the triggering request. Compare against neighbouring skills so the distinction is clear — two skills with interchangeable descriptions are worse than either alone.
  10. Review the batch with multi-review if available: scope fidelity, unsupported generalization, overlap, operational correctness, usability. Give reviewers redacted drafts. A review of an earlier plan is not a review of the skills subsequently written.
  11. Install, then exercise. Install with skill_manage, confirm with skill_view, then run the procedure against a representative request. If the skill ships a script, run it with real inputs and read the real output. A skill that parses is not a skill that works.
  12. Report what changed. New capabilities and targeted updates, concisely. Work through the batch without asking permission at each step; stop only for genuine scope or authority decisions.

Evidence discipline

  • Pick the right counter for the question. use_count includes cron and slash-command injection; view_count and skill_view calls are the model-chosen signal. Neither is correct in general. audit.py uses use_count because it asks "is this skill live"; harvest.py uses skill_view because it asks "did the model reach for this".
  • A prior skill_view call proves a request to load — not successful loading, not retention through compaction, and not adherence.
  • Compare success and failure episodes within the same task shape. Do not infer causes from global correction rates.
  • Repetition caused by copied history is not independent evidence. If counts are not deduplicated, report representative examples instead of totals.
  • Preserve the distinction between "cause unknown" and "verified missing procedure". A causal study of every failure is not a prerequisite to writing down a workflow that demonstrably worked.

Pitfalls

  1. Counting machine-authored turns as owner corrections. Reviewer prompts, judge rubrics, and system notes are stored with role='user' on interactive sources, and they are dense in correction vocabulary because critique prompts are about finding errors. Measured on one real profile: 2,072 of ~9,000 role=user rows were machine-authored, and a bare \bwrong\b matched 649 rows that were almost entirely reviewer prompts. Filter by preamble, not just by session source.
  2. Mismatched denominators in a lift calculation. If per-skill rates count only pre-correction loads, the baseline must too. Getting this wrong produced a table where every skill scored below 1.00x — arithmetically impossible for a weighted average, and the tell that the populations disagreed.
  3. Counting a skill loaded after the complaint. A skill loaded in response to a correction is not a cause of it. Enforce timestamp precedence.
  4. Splitting one skill across name variants. Agents call skill_view with category/name, colon forms, doubled names, and trailing prose. Unnormalised, each fragment falls under the session floor and the skill disappears from the report — looking unused rather than under-counted.
  5. Quoting lift as an effect. Hard tasks load more skills and draw more corrections. A high lift may mark difficulty, not a defective skill.
  6. Optimizing for skills created. The measure is less rediscovery. Updating an existing skill is usually the better outcome.
  7. Shipping analysis scripts that depend on intermediate files. A script that reads paths from a one-off investigation is not reusable by anyone, including you next quarter.

Verification

  • Candidate evidence traces to attributable episodes with surrounding context
  • Each new skill has a distinct workflow, or the lesson updated its existing owner
  • No unsupported universal rules and no fabricated occurrence counts
  • Drafts themselves reviewed, not just the plan that proposed them
  • Installed content loads through the runtime and was exercised on a real request
  • Any shipped script run end-to-end against real inputs, output read
  • Statistical claims carry their confounds in the same breath
  • Checkpoint advanced only after findings were saved

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.