Post Mortem
thananon/9arm-skills
Write the canonical engineering record of a fixed bug — root cause, mechanism, fix, validation, and how it slipped through.
A skill your agent uses when a mistake, correction, or surprise taught the workspace something that must stick — a retro or postmortem, the same agent error corrected twice, a resolved bug's root…
Install Continuous Learning
$ npx skills add ericrisco/rsc-harness --skill continuous-learning -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install ericrisco/rsc-harness continuous-learning --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/ericrisco/rsc-harness.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/continuous-learning .claude/skills/continuous-learning && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "continuous-learning" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learning into .claude/skills/continuous-learning/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "continuous-learning", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learningType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add ericrisco/rsc-harness --skill continuous-learning -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install ericrisco/rsc-harness continuous-learning --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ericrisco/rsc-harness.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/continuous-learning .agents/skills/continuous-learning && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "continuous-learning" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learning into .agents/skills/continuous-learning/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "continuous-learning", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add ericrisco/rsc-harness --skill continuous-learning -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install ericrisco/rsc-harness continuous-learning --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ericrisco/rsc-harness.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/continuous-learning .cursor/skills/continuous-learning && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "continuous-learning" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learning into .cursor/skills/continuous-learning/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "continuous-learning", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/ericrisco/rsc-harness.git --path skills/continuous-learning--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add ericrisco/rsc-harness --skill continuous-learning -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install ericrisco/rsc-harness continuous-learning --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ericrisco/rsc-harness.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/continuous-learning .gemini/skills/continuous-learning && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "continuous-learning" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learning into .gemini/skills/continuous-learning/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "continuous-learning", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install ericrisco/rsc-harness continuous-learningInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add ericrisco/rsc-harness --skill continuous-learning -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/ericrisco/rsc-harness.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/continuous-learning .github/skills/continuous-learning && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "continuous-learning" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learning into .github/skills/continuous-learning/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "continuous-learning", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add ericrisco/rsc-harness --skill continuous-learning -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install ericrisco/rsc-harness continuous-learning --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/ericrisco/rsc-harness.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/continuous-learning .opencode/skills/continuous-learning && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "continuous-learning" agent skill from https://github.com/ericrisco/rsc-harness/tree/main/skills/continuous-learning into .opencode/skills/continuous-learning/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "continuous-learning", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
continuous-learning- GitHub stars
- 156
- Token cost
- ~2.5k tokens
- SKILL.md length
- 1,332 words
- Files
- 4 (incl. references)
- Skills in repo
- 229
- Repo updated
- First seen
- Licence
- MIT
At a glance
A skill your agent uses when a mistake, correction, or surprise taught the workspace something that must stick — a retro or postmortem, the same agent error corrected twice, a resolved bug's root…
- Works in 5 steps: Harvest — pull the lesson out of chat… → Root-cause, blameless — name the system… → Route to a durable home — pick the… → …
- Surprise taught the workspace something that must stick — a retro
- SKILL.md covers Boundaries, The capture loop, Routing decision table and The "2+ recurrences ⇒…, plus 4 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Continuous Learning is an agent skill from ericrisco/rsc-harness. Use when a mistake, correction, or surprise taught the workspace something that must stick — a retro or postmortem, the same agent error corrected twice, a resolved bug's root cause, scattered notes-to-self — and route that lesson to the durable surface that fires next time. NOT a forward choice with alternatives (that is decision-records).
Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `evals/README.md`, `evals/cases.yaml` and `references/lesson-routing.md`).
It sits in DevOps & Cloud, covering Runbooks and postmortems and Root cause analysis. The repository describes itself as: Your agent invents things because it has no memory, and can't touch your database because it has no arms. rsc is the meta-harness that gives it both, plus the trade to know the… The licence is MIT.
When your agent uses it
- Surprise taught the workspace something that must stick — a retro
- The same agent error corrected twice
- A resolved bugs root cause
- Scattered notes-to-self — and route that lesson to the durable surface that fires next time
Example prompts
- “/continuous-learning”
Workflow steps
5 steps, taken from the first numbered list in SKILL.md.
- Harvest — pull the lesson out of chat now, while it is still in context. Why: the next compaction deletes it for free.
- Root-cause, blameless — name the system gap: a missing rule, a wrong assumption, an under-specified skill, an absent guardrail. Never "the…
- Route to a durable home — pick the cheapest surface that will fire next time (table below). Prefer the preventative write that kills the…
- Write it — land the entry in that surface in the lesson format below. If the home is a skill body, a description, or an eval, delegate the…
- Verify it fires — prove the lesson is live (see "Verify it fires next time"). Why: learning loops do not fail at the retro, they fail…
What it can do on your machine
Read from SKILL.md and the folder at commit 92fde8f. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Continuous Learning loads about 2.5k tokens when it runs, and up to ~3.7k if it reads all its reference files. Until then it costs about 91 tokens; SKILL.md has 1,332 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from ericrisco/rsc-harness at commit 92fde8f, republished under its MIT licence (© ericrisco). 1,332 words, ~2,455 tokens.
Download SKILL.mdSave it as
.claude/skills/continuous-learning/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.- name
- continuous-learning
- description
- Use when a mistake, correction, or surprise taught the workspace something that must stick — a retro or postmortem, the same agent error corrected twice, a resolved bug's root cause, scattered notes-to-self — and route that lesson to the durable surface that fires next time. NOT a forward choice with alternatives (that is `decision-records`).
- tags
- learning, retro, postmortem, feedback-loop, knowledge, meta
- recommends
- decision-records, author-skill, debug, harness, knowledge-ops
- origin
- risco
Continuous learning — the feedback loop of the harness
This is the engine that makes the system get better every time it is wrong. When something broke, got corrected, surprised you, or simply taught the workspace something, your job is to catch that lesson and route it back into the durable apparatus so the same mistake cannot recur.
One premise is load-bearing: a lesson that lives only in chat is gone at the next compaction. Verbal reflection only changes future behaviour when it is persisted to memory the agent actually reads next time (this is the Reflexion mechanism — self-reflection written to durable memory, not held in the conversation). In this harness, "memory" is a concrete set of surfaces: a SKILL.md body, 02-DOCS/wiki/harness/decisions.md, 02-DOCS/wiki/harness/user-profile.md, a root CLAUDE.md rule, or a verify.sh check. Chat is not memory. A lesson is "captured" only when it has landed in one of those.
Read technical_level in 02-DOCS/wiki/harness/user-profile.md before you narrate, and speak in the orient voice in that register. It governs the words only — the capture loop runs identically for every reader.
Boundaries
| Situation | Owner | Why |
|---|---|---|
| "We chose Postgres over Mongo, here's the why + the rejected options" | ../decision-records/SKILL.md | forward choice with alternatives; a choice is not a lesson from a mistake |
| "The migration failed because Postgres rejects NULL on the PK — never assume that again" | continuous-learning | backward lesson from a mistake |
| "Find the bug causing the 500" | ../debug/SKILL.md | in-the-moment diagnosis; you run after it resolves |
| "Now that debug found it, make sure we never ship that pattern again" | continuous-learning | post-resolution capture |
| "Write the SKILL.md and evals for pr-describe" | ../author-skill/SKILL.md | skill craft — body, description, evals |
| "This lesson means the deploy skill needs a new guardrail" | continuous-learning decides the home → ../author-skill/SKILL.md makes the edit | you route, it writes |
| "Consolidate these docs / sweep the inbox" | ../harness/SKILL.md | generic 02-DOCS filing; your trigger is "we learned something the hard way" |
| "What do I know about X" | ../knowledge-ops/SKILL.md | reference knowledge, as opposed to mistake-derived experiential knowledge |
| "Run this sweep every week" | loop / schedule harness CLI | you may recommend a cadence; you are not a scheduler |
The capture loop
Five steps. Run them in order; do not stop before step 5.
- Harvest — pull the lesson out of chat now, while it is still in context. Why: the next compaction deletes it for free.
- Root-cause, blameless — name the system gap: a missing rule, a wrong assumption, an under-specified skill, an absent guardrail. Never "the agent is careless" or "the user keeps forgetting". Why: blame indicts a person and the loop stops running; blameless framing focuses on contributing causes and keeps the retro honest (Google SRE / Atlassian blameless postmortem practice).
- Route to a durable home — pick the cheapest surface that will fire next time (table below). Prefer the preventative write that kills the whole class of failure over a one-off note that just records it. Why: good postmortems split mitigative-vs-preventative action items, and the preventative one is what stops recurrence.
- Write it — land the entry in that surface in the lesson format below. If the home is a skill body, a description, or an eval, delegate the edit to
author-skill— you decide the home, it does the craft. - Verify it fires — prove the lesson is live (see "Verify it fires next time"). Why: learning loops do not fail at the retro, they fail after it — at action-tracking and trend analysis (incident.io / Rootly 2025 SRE best-practice consensus). If you cannot point to where it fires, you have not captured it.
Routing decision table
The single most important artifact in this skill. Pick the row, write to that exact home, hand off to that writer.
| Lesson type | Durable home (exact path) | Who writes it |
|---|---|---|
| About the user (prefers X, hates Y, works this way) | 02-DOCS/wiki/harness/user-profile.md | this skill |
| A rule we keep breaking | root CLAUDE.md rule, or the relevant SKILL.md body | author-skill for the skill body; this skill for CLAUDE.md |
| A pattern to ban | a verify.sh banlist/check on the owning skill | author-skill |
| A missed-trigger insight (skill fired wrong / didn't fire) | a should_not_trigger (or should_trigger) eval case | author-skill |
| A surprising fact / how a provider actually behaves | wiki article via the harness ingest protocol | harness |
| A forward choice that surfaced mid-retro | punt to decisions.md | decision-records |
| A one-off, low-stakes note | 02-DOCS/wiki/harness/decisions.md append, or a topic note | this skill |
Full catalogue with hand-off recipes and a worked end-to-end example is in references/lesson-routing.md. The body table is enough for routine cases; read the reference when the home or the hand-off is unobvious.
The "2+ recurrences ⇒ structural fix" rule
First sighting of a lesson: a note is fine. Second sighting of the same class: stop noting and build a guardrail — a CLAUDE.md rule, a verify.sh check, or a should_not_trigger eval. A third note proves the second note did nothing.
Why: this is exactly where learning loops die. Teams nail the postmortem and then fumble trend analysis — the recurring class never gets a structural fix, so it keeps recurring. The recurrence is the signal that prose has failed; answer it with a check, not another apology.
Show full SKILL.md (496 more words)Show less
Lesson entry format
Copy-pasteable and situation-tagged, so it retrieves on the trigger that matters — not as a vague blob nobody can act on (experiential memory works when entries are actionable and situation-tagged, not when they are similarity soup):
## <date> — <short lesson title>
- **Situation:** <when this fires / the trigger phrasing>
- **We believed:** <the wrong assumption>
- **Actually:** <what is true>
- **Durable home:** <path + surface that now holds it>
- **Fires next time via:** <rule / eval / verify.sh / index entry in `02-DOCS/wiki/index.md` (the Knowledge map; root `CLAUDE.md` keeps only a short pointer)>The last two lines are not optional. An entry with no durable home and no "fires next time" is a chat message with a date on it.
Verify it fires next time
This is the rigor of this process skill, and it stands in for a verify.sh (this skill emits no checkable artifact of its own — see below). Acceptance: you can point to a concrete place where the lesson now changes behaviour:
- a rule the agent reads on its next pass (
CLAUDE.mdor a skill body), or - an eval case (
should_not_trigger/should_trigger) that would have caught the miss, or - a
verify.shcheck on the owning skill that fails on the banned pattern, or - a
02-DOCS/wiki/index.mdentry (the Knowledge map; rootCLAUDE.mdkeeps only a short pointer) pointing at the new wiki article.
If you cannot name one of those, the lesson is not captured — keep going. Prefer a surface a human can review (a rule, an eval, a profile line) over an opaque store: a single agent reflecting alone can talk itself into a local optimum, so the durable write should be legible enough for a human to sanity-check.
This skill has no scripts/verify.sh. Its output is a routing decision plus a durable write into another surface. The check that the lesson fires lives in that target surface — a verify.sh on the deploy skill, a should_not_trigger eval, a CLAUDE.md rule — not here. Its rigor is the capability eval, same as decision-records, author-skill, and harness.
Periodic retro sweep
To harvest scattered corrections and notes-to-self on a cadence, do not reimplement a scheduler — recommend the loop / schedule harness CLI to run the sweep weekly. For pulling raw notes through 02-DOCS/inbox/ into the wiki, route the consolidation itself through ../harness/SKILL.md; you only own the lessons that came from a mistake, not the general filing.
Anti-patterns
| Anti-pattern | Why it fails | Do instead |
|---|---|---|
| Lesson captured only in chat | lost at the next compaction | write it to a durable surface from the table |
| "The agent/user is bad at X" | blame indicts a person; the loop stops running | name the system gap (missing rule, wrong assumption) |
| Note added but it never fires | prose nobody reads next time is not a capture | attach a rule / eval / check, then verify it fires |
| Re-noting the same class a 3rd time | the 2nd note already proved prose failed | build a guardrail on the 2nd sighting |
| Hand-editing the SKILL.md yourself | you do not own skill craft | hand the edit to author-skill |
| Capturing a forward choice here | that is a decision, not a lesson | route to decision-records |
| A vague vector-blob note | won't retrieve, can't be acted on | situation-tag it in the entry format |
| Starting to diagnose the bug | that is debug's job | come here after it resolves, with the root cause |
© ericrisco, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 3 other files (references) in skills/continuous-learning of ericrisco/rsc-harness.
- SKILL.md
- evals/README.md
- evals/cases.yaml
- references/lesson-routing.md
Open the folder on GitHubat commit 92fde8f
Compare with similar skills
Continuous Learning next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Continuous Learning this skillericrisco/rsc-harness | 156 | — | ~2.5k | Automated safety check: Pass | MIT | |
| Post Mortemthananon/9arm-skills | 3.2k | — | ~3.4k | Automated safety check: Pass | None | |
| Post-Incident DebriefVeryGoodOpenSource/vgv-wingspan | 108 | — | ~1.9k | Automated safety check: Pass | MIT | |
| Postmortemalirezarezvani/claude-skills | 28k | 2 repos | ~2k | Automated safety check: Pass | MIT | |
| Postmortemdralgorhythm/claude-agentic-framework | 124 | — | ~708 | Automated safety check: Pass | None | |
| Conducting Post Incident Lessons Learnedmukul975/Anthropic-Cybersecurity-Skills | 34k | — | ~1.7k | Automated safety check: Pass | Apache-2.0 |
Similar skills
Post-Incident Debrief
VeryGoodOpenSource/vgv-wingspan
Produces a blameless post-incident debrief with timeline, root cause and follow-up actions after an outage, failed release or significant bug, while details are fresh.
Postmortem
alirezarezvani/claude-skills
/em:postmortem — Honest analysis of what went wrong. An agent skill from alirezarezvani/claude-skills.
Postmortem
dralgorhythm/claude-agentic-framework
Runs this framework's blameless postmortem workflow — reconstruct the incident timeline from evidence, drive five-whys to a mechanism-level root cause, and produce owner-and-due-date action items…
Conducting Post Incident Lessons Learned
mukul975/Anthropic-Cybersecurity-Skills
Facilitate structured post-incident reviews to identify root causes, document what worked and failed, and produce actionable recommendations to improve future incident response.
- Official
Incident Postmortem
github/awesome-copilot
A skill your agent uses when an outage, production incident, or significant service degradation has occurred and the team needs to write a structured blameless post-mortem.
More from ericrisco/rsc-harness
All 229 skills in this repoAb Testing
ericrisco/rsc-harness
A skill your agent uses when designing or analyzing a controlled experiment — falsifiable hypothesis, sample size from an MDE, reading significance/CI/power, CUPED, or rescuing tests that won't go…
Accessibility
ericrisco/rsc-harness
A skill your agent uses when making a web UI conform to WCAG 2.2 Level AA — axe-core or Lighthouse a11y violations, keyboard operability, focus management, ARIA roles/names/live regions, contrast…
Ads
ericrisco/rsc-harness
A skill your agent uses when running or fixing paid acquisition on Google or Meta — campaign structure (Performance Max, Demand Gen, Search, Advantage+), platform-fit creative, budget/scaling rules…
Agent Eval
ericrisco/rsc-harness
A skill your agent uses when measuring whether an LLM or agent system actually got better and gating merges on it: golden sets, fixing an inflated LLM-as-judge, scoring RAG (faithfulness, contextual…
AI Media
ericrisco/rsc-harness
A skill your agent uses when a creative goal must become a finished media file: pick and order generative-media models per modality — AI voiceover, image-to-video clips, score — then glue them with…
Analytics
ericrisco/rsc-harness
A skill your agent uses when instrumenting product or web analytics — GA4/PostHog SDK wiring, event taxonomy, funnels, double-counted events, consent gating, PII scrubbing.
Related
Categories
Questions about Continuous Learning
What does Continuous Learning do?
A skill your agent uses when a mistake, correction, or surprise taught the workspace something that must stick — a retro or postmortem, the same agent error corrected twice, a resolved bug's root…. Continuous Learning is an agent skill from ericrisco/rsc-harness. Use when a mistake, correction, or surprise taught the workspace something that must stick — a retro or postmortem, the same agent error corrected twice, a resolved bug's root cause, scattered notes-to-self — and route that lesson to the durable surface that fires next time.
When should I use Continuous Learning?
Continuous Learning fits situations like: surprise taught the workspace something that must stick — a retro; the same agent error corrected twice; A resolved bugs root cause; scattered notes-to-self — and route that lesson to the durable surface that fires next time.
How do I install Continuous Learning in Claude Code?
Run `npx skills add ericrisco/rsc-harness --skill continuous-learning -a claude-code`. Or copy the skill folder (skills/continuous-learning in ericrisco/rsc-harness) into .claude/skills/continuous-learning in your project. Claude Code loads it when a task matches its description.
How do I install Continuous Learning in Codex?
Run `npx skills add ericrisco/rsc-harness --skill continuous-learning -a codex`. Or copy the skill folder (skills/continuous-learning in ericrisco/rsc-harness) into .agents/skills/continuous-learning in your project. Codex loads it when a task matches its description.
Can I use Continuous Learning in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ericrisco/rsc-harness --skill continuous-learning -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/continuous-learning, .gemini/skills/continuous-learning, .github/skills/continuous-learning and .opencode/skills/continuous-learning in your project.
What does Continuous Learning need to run?
SKILL.md names no scripts, command-line tools or credentials: Continuous Learning is instructions for the agent only.
Does Continuous Learning access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Continuous Learning safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Continuous Learning use?
Continuous Learning is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Continuous Learning use?
About 2.5k tokens (SKILL.md is roughly 9.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.3k tokens, read only when the agent opens those files.
What are the alternatives to Continuous Learning?
Skills that share tags, products or a category with Continuous Learning: Post Mortem (thananon/9arm-skills, 3.2k stars), Post-Incident Debrief (VeryGoodOpenSource/vgv-wingspan, 108 stars), Postmortem (alirezarezvani/claude-skills, 28k stars) and Postmortem (dralgorhythm/claude-agentic-framework, 124 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Continuous Learning?
ericrisco (a GitHub user) maintains it in ericrisco/rsc-harness, which has 156 GitHub stars. The repository holds 229 skills in this directory. The repository was last updated on October 6, 2026.
Source: ericrisco/rsc-harness on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.