Agent skill

Learn New Things

by Abilityai in Abilityai/cornelius

Continuous learning heartbeat - autonomously researches, extracts insights, and expands knowledge base

MITAuto-check: notesKnowledge Management

Install Learn New Things

skills CLI
$ npx skills add Abilityai/cornelius --skill learn-new-things -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Abilityai/cornelius learn-new-things --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Abilityai/cornelius.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/learn-new-things .claude/skills/learn-new-things && rm -rf skills-src

Use ~/.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/

Facts

Skill name
learn-new-things
GitHub stars
109
Token cost
~5k tokens
SKILL.md length
1,041 words
Files
1
Skills in repo
51
Repo updated
First seen
Licence
MIT

At a glance

Continuous learning heartbeat - autonomously researches, extracts insights, and expands knowledge base

  • Works in 11 steps: Initialize State → Pre-Cycle Preparation → Topic Selection → …
  • Tasks that involve Knowledge bases
  • SKILL.md covers Overview, Dependencies, Usage and State Tracking, plus 8 more sections
  • Calls git and gh; reaches github.com

What it does

Learn New Things is an agent skill from Abilityai/cornelius. Continuous learning heartbeat - autonomously researches, extracts insights, and expands knowledge base

Its SKILL.md is about 5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Knowledge Management, covering Knowledge bases. The repository describes itself as: AI-powered second brain template for Claude Code + Obsidian. The licence is MIT.

When your agent uses it

  • Tasks that involve Knowledge bases

Example prompts

  • “/learn-new-things”

Requirements

  • Pre-approved tools (allowed-tools): Task, Read, Write, Bash, Glob, Grep

Workflow steps

11 steps, taken from the step headings in SKILL.md.

  1. Initialize State
  2. Pre-Cycle Preparation
  3. Topic Selection
  4. Execute Deep Research
  5. Extract Insights
  6. Discover Connections
  7. Update State & Log
  8. Git Commit & Branch Management
  9. Error Handling
  10. Cycle Summary
  11. Schedule Next Cycle

What it can do on your machine

Read from SKILL.md and the folder at commit fd5e9a4. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Task
    • Read
    • Write
    • Bash
    • Glob
    • Grep

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    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

Learn New Things loads about 5k tokens when it runs. Until then it costs about 30 tokens; SKILL.md has 1,041 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~30
When it runs · the whole SKILL.md, loaded when a task matches
~5k

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: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Task, Read, Write, Bash, Glob, Grep

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 Abilityai/cornelius at commit fd5e9a4, republished under its MIT licence (© Abilityai). 1,041 words, ~4,981 tokens.

Download SKILL.mdSave it as .claude/skills/learn-new-things/SKILL.md (or your agent's skills folder).
name
learn-new-things
description
Continuous learning heartbeat - autonomously researches, extracts insights, and expands knowledge base
allowed-tools
Task, Read, Write, Bash, Glob, Grep
user-invocable
true
disable-model-invocation
true
argument-hint
[interval-hours] [topic]
automation
gated

Learn New Things - Continuous Learning Heartbeat

Autonomous learning loop that periodically expands the knowledge base through research, extraction, and connection discovery. Runs locally using existing skills and sub-agents.

Overview

This heartbeat skill implements a continuous learning cycle:

  1. Research - Discover cutting-edge papers and developments
  2. Extract - Pull unique insights into Document Insights
  3. Connect - Map discoveries to existing knowledge base
  4. Commit - Save results to dedicated git branch, return to main
  5. Rest - Wait for next cycle

Each cycle is a complete learning session. The heartbeat never "completes" - it continuously learns.

Git Workflow: Each learning session commits to its own branch (learning/YYYY-MM-DD-topic-slug), then returns to main. This keeps main clean while preserving all learning for selective merging.

Dependencies

  • Skills: /deep-research, /auto-discovery, /integrate-recent-notes, /refresh-index
  • Sub-agents: research-specialist, document-insight-extractor, connection-finder
  • Local Brain Search: For semantic search and connection discovery

Usage

bash
/learn-new-things                    # Default: 8-hour interval, auto-select topic
/learn-new-things 4                  # 4-hour interval
/learn-new-things 8 "multi-agent systems"  # Specific topic
/learn-new-things stop               # Stop the learning loop

State Tracking

Track learning progress in resources/learn-new-things-log.md:

yaml
session_id: YYYY-MM-DD-HHMMSS
last_cycle: 2026-02-18T13:15:00
cycles_completed: 0
topics_researched: []
insights_extracted: 0
connections_discovered: 0
consecutive_errors: 0
phase: "running"  # running | paused | error
branches_created: []  # e.g., ["learning/2026-02-18-embodied-cognition"]

STEP 1: Initialize State

Read or create state file:

bash
cat resources/learn-new-things-log.md 2>/dev/null || echo "No existing state"

Parse arguments:

  • $ARGUMENTS[0] - Interval in hours (default: 8)
  • $ARGUMENTS[1] - Optional topic (default: auto-select)

If argument is "stop", set phase: "paused" and exit.


STEP 2: Pre-Cycle Preparation

Ensure Index is Fresh

Check when index was last updated:

bash
ls -la resources/local-brain-search/data/brain.faiss

If older than 24 hours, refresh:

bash
resources/local-brain-search/run_reindex.sh
Check Knowledge Base State

Read current analysis:

bash
head -100 knowledge-base-analysis.md

Note:

  • Current note counts
  • Identified gaps
  • Recent research sessions

STEP 3: Topic Selection

If Topic Provided

Use the provided topic from $ARGUMENTS[1].

If Auto-Select (Default)

Select topic based on knowledge base gaps and rotation. Use these strategies:

Strategy A: Gap-Filling Choose from underrepresented domains in knowledge-base-analysis.md:

  • Systems thinking & complexity science (12 notes - gap)
  • Embodiment & interoception (14 notes - gap)
  • Creativity neuroscience
  • Memory consolidation
  • Collective intelligence

Strategy B: Depth-Building Extend existing strong domains:

  • AI agent architectures (latest 2025-2026 developments)
  • Neuroscience of decision-making
  • Buddhism-neuroscience bridges
  • Identity and belief systems

Strategy C: Emerging Trends Research cutting-edge developments:

  • Latest AI safety research
  • New consciousness research
  • Recent dopamine/motivation findings
  • Multi-agent coordination

Rotation Logic:

cycle_num = cycles_completed % 3
if cycle_num == 0: Strategy A (gap-filling)
if cycle_num == 1: Strategy B (depth-building)
if cycle_num == 2: Strategy C (emerging)

Document selected topic and rationale.


STEP 4: Execute Deep Research

Launch the deep-research skill with selected topic:

Use Task tool with subagent_type='research-specialist':

TOPIC: [Selected topic]

Conduct comprehensive research on [topic] focusing EXCLUSIVELY on the most recent research and developments (2025-2026).

SEARCH STRATEGY:
- Prioritize papers from last 12-18 months
- Search for "2025", "2026", "recent", "latest" in queries
- Check arXiv preprints, major conferences (NeurIPS, ICML, ICLR)
- Look for industry whitepapers and blog posts

OUTPUT REQUIREMENTS:
- 15-25 major papers/developments
- Full citations with DATES
- Key findings and novel contributions
- Save to: resources/[Topic-Slug]-Research-YYYY-MM-DD.md

On Success: Continue to Step 5 On Failure: Log error, increment consecutive_errors, check threshold


STEP 5: Extract Insights

Create Session Folder

Format: YYYY-MM-DD [Topic Description]

bash
date '+%Y-%m-%d'
# Create: Brain/Document Insights/YYYY-MM-DD [Topic]/
Launch Document Insight Extractor

Use Task tool with subagent_type='document-insight-extractor':

Extract unique insights from the research report for the knowledge base.

SOURCE DOCUMENT: [Path to research report from Step 4]
SESSION FOLDER: [Session folder name]

EXTRACTION GUIDELINES:
1. Focus on novel insights (paradigm shifts, counter-intuitive findings)
2. Bridge to existing hubs: Consciousness, Dopamine, Decision-Making, Identity, AI Agents, Flow
3. Quality > Quantity: 15-25 high-value insights
4. ALWAYS search for duplicates before creating notes
5. Create changelog in session folder

On Success: Count insights extracted, continue to Step 6 On Failure: Log error, continue to Step 6 (partial success is OK)


STEP 6: Discover Connections

Launch Connection Finder

Use Task tool with subagent_type='connection-finder':

Discover connections between newly extracted insights and existing knowledge base.

STARTING POINTS: All notes in session folder: [Session folder path]

CONNECTION DISCOVERY GOALS:
1. Bridge to existing 530+ permanent notes
2. Link to 6 primary thematic hubs
3. Find cross-domain consilience opportunities
4. Similarity thresholds: 0.65-0.85

OUTPUT:
- Connection map for new insights
- Synthesis opportunities identified
- Changelog: CHANGELOG - Connection Discovery Session YYYY-MM-DD.md in Brain/05-Meta/Changelogs/

On Success: Count connections, continue to Step 7 On Failure: Log error, continue to Step 7


STEP 7: Update State & Log

Update State File

Write to resources/learn-new-things-log.md:

markdown
# Learn New Things - Session Log

**Session ID:** [session_id]
**Last Updated:** [timestamp]
**Phase:** running

## Statistics
- Cycles completed: [N]
- Topics researched: [list]
- Total insights extracted: [N]
- Total connections discovered: [N]
- Consecutive errors: [N]

## Latest Cycle
- **Started:** [timestamp]
- **Topic:** [topic]
- **Research report:** [path]
- **Session folder:** [path]
- **Insights extracted:** [N]
- **Connections found:** [N]
- **Status:** [success/partial/error]

## Cycle History
| Date | Topic | Insights | Connections | Status |
|------|-------|----------|-------------|--------|
| YYYY-MM-DD | [topic] | [N] | [N] | [status] |
Log to Master Changelog

Add entry to Brain/CHANGELOG.md:

markdown
## YYYY-MM-DD - Learning Heartbeat Cycle [N]

- **Topic:** [topic]
- **Insights extracted:** [N]
- **Connections discovered:** [N]
- **Session folder:** [[Document Insights/YYYY-MM-DD Topic]]

STEP 8: Git Commit & Branch Management

After completing the learning cycle, commit all changes to a dedicated branch, then return to main.

Create Branch Name

Generate branch name from topic and date:

bash
# Get current date
DATE=$(date '+%Y-%m-%d')

# Create topic slug (lowercase, hyphens, no special chars)
# Example: "Multi-Agent Systems" → "multi-agent-systems"
TOPIC_SLUG=$(echo "[topic]" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//' | sed 's/-$//')

BRANCH_NAME="learning/${DATE}-${TOPIC_SLUG}"
Ensure Clean State on Main

Before creating the learning branch, ensure we're on main:

bash
cd $PROJECT_ROOT
git stash --include-untracked -m "Pre-learning stash $(date '+%Y-%m-%d %H:%M')" 2>/dev/null || true
git checkout main
git pull origin main 2>/dev/null || true
git stash pop 2>/dev/null || true
Create and Switch to Learning Branch
bash
git checkout -b "$BRANCH_NAME"
Stage Learning Results

Stage all files created during this cycle:

bash
# Research report
git add "resources/[Topic-Slug]-Research-*.md"

# Document Insights session folder
git add "Brain/Document Insights/[Session-Folder]/"

# Changelogs
git add "Brain/05-Meta/Changelogs/CHANGELOG - *.md"
git add "Brain/CHANGELOG.md"

# State file
git add "resources/learn-new-things-log.md"

# Local Brain Search index updates (if any)
git add "resources/local-brain-search/data/" 2>/dev/null || true
Commit with Descriptive Message
bash
git commit -m "$(cat <<'EOF'
Learning: [Topic] - Cycle [N]

Research & Extraction Session:
- Topic: [topic]
- Papers analyzed: [N]
- Insights extracted: [N]
- Connections discovered: [N]

Session folder: Brain/Document Insights/[Session-Folder]/
Research report: resources/[filename]

Generated by /learn-new-things heartbeat
EOF
)"
Push Branch to Remote
bash
git push -u origin "$BRANCH_NAME"
Create Pull Request

Create a PR for review and selective merging:

bash
gh pr create --title "Learning: [Topic] - Cycle [N]" --body "$(cat <<'EOF'
## Learning Session Summary

**Topic:** [topic]
**Date:** YYYY-MM-DD
**Cycle:** [N]

### Research Results
- Papers analyzed: [N]
- Insights extracted: [N]
- Connections discovered: [N]

### Files Added
- Research report: `resources/[filename]`
- Session folder: `Brain/Document Insights/[Session-Folder]/`
- Changelogs updated

### Key Discoveries
1. [Most significant insight]
2. [Cross-domain connection found]
3. [Synthesis opportunity identified]

### Review Checklist
- [ ] Insights are high quality and non-redundant
- [ ] Connections to existing notes are valid
- [ ] No sensitive or incorrect information

---
🤖 Generated by `/learn-new-things` heartbeat
EOF
)"

Store PR URL in state file for reference:

markdown
## Latest Cycle
...
- **Pull Request:** https://github.com/[repo]/pull/[N]

If PR creation fails:

  • Branch still exists on remote
  • PR can be created manually later
  • Continue to next cycle
Return to Main Branch
bash
git checkout main
Verify Clean State
bash
git status
# Should show: "On branch main, nothing to commit, working tree clean"
# Or show unrelated pending changes (not from learning cycle)
Log Branch Info

Update state file with branch information:

markdown
## Latest Cycle
...
- **Git branch:** learning/YYYY-MM-DD-topic-slug
- **Branch pushed:** yes/no
- **Main restored:** yes
Git Error Handling

If branch creation fails:

  • Log error, continue on main
  • Learning results remain uncommitted
  • Flag for manual review

If push fails:

  • Branch exists locally
  • Can be pushed manually later
  • Continue to next cycle

If checkout main fails:

  • CRITICAL: Do not proceed to next cycle
  • Increment consecutive_errors
  • Manual intervention required

STEP 9: Error Handling

Check Error Threshold

If consecutive_errors >= 3 OR git checkout main failed:

markdown
## LEARNING HEARTBEAT PAUSED

**Error:** 3 consecutive cycles failed
**Last topic:** [topic]
**Last error:** [error description]

Manual intervention required. Check:
1. Network connectivity for research
2. Local Brain Search index health
3. Disk space for new notes

To resume: `/learn-new-things`

Set phase: "error" and stop.

Show full SKILL.md (413 more words)Show less
Reset on Success

If cycle completes successfully:

  • Set consecutive_errors = 0
  • Increment cycles_completed
  • Add topic to topics_researched

STEP 10: Cycle Summary

Display cycle summary:

markdown
## Learning Cycle [N] Complete

**Topic:** [topic]
**Duration:** [time]

### Results
- Research papers analyzed: [N]
- Unique insights extracted: [N]
- Connections discovered: [N]

### Key Discoveries
1. [Most significant insight]
2. [Cross-domain connection]
3. [Synthesis opportunity]

### Files Created
- Research report: `resources/[filename]`
- Session folder: `Brain/Document Insights/[folder]`
- Changelogs updated

### Git
- **Branch:** `learning/YYYY-MM-DD-topic-slug`
- **Pushed to remote:** yes
- **Pull Request:** [PR URL]
- **Returned to main:** yes

### Next Cycle
- Scheduled in: [interval] hours
- Suggested topic: [next topic based on rotation]

STEP 11: Schedule Next Cycle

Set timer for next learning cycle:

bash
INTERVAL_HOURS=${1:-8}
INTERVAL_SECONDS=$((INTERVAL_HOURS * 3600))
sleep $INTERVAL_SECONDS && echo "HEARTBEAT: learn-new-things ready for next cycle"

Run with run_in_background: true.

Important: The heartbeat only continues if you respond to "HEARTBEAT: learn-new-things" prompt.


Stopping the Loop

Automatic pause:

  • 3+ consecutive errors

Manual stop:

  • Run /learn-new-things stop
  • Don't respond to "HEARTBEAT:" prompts
  • Say "stop learning"

Resume:

  • Run /learn-new-things again

Configuration

Modifiable Parameters

Edit this skill to adjust:

ParameterDefaultDescription
interval_hours8Hours between cycles
max_errors3Consecutive errors before pause
insights_per_cycle15-25Target insight count
connection_threshold0.65-0.85Similarity range
Topic Rotation

The rotation pattern can be customized:

Cycle 0, 3, 6, 9... → Gap-filling (underrepresented domains)
Cycle 1, 4, 7, 10... → Depth-building (strong domains)
Cycle 2, 5, 8, 11... → Emerging trends (cutting-edge)

Examples

Example 1: Start with Defaults
/learn-new-things

→ Starts 8-hour learning loop
→ Auto-selects topic based on gaps
→ Runs research → extract → connect
→ Schedules next cycle in 8 hours
Example 2: Specific Topic, Faster Cycle
/learn-new-things 4 "embodied cognition"

→ 4-hour interval
→ Researches embodied cognition specifically
→ Useful for filling known gap quickly
Example 3: Check Status
cat resources/learn-new-things-log.md

→ See cycles completed, topics covered
→ Review error history
→ Check next scheduled cycle
Example 4: Stop Learning
/learn-new-things stop

→ Pauses the heartbeat
→ Preserves state for later resume
→ No new cycles scheduled

Managing Learning Branches & Pull Requests

Each learning cycle creates a branch (learning/YYYY-MM-DD-topic-slug) and opens a Pull Request. This provides a formal review workflow for learning results.

List Open Learning PRs
bash
gh pr list --search "Learning:" --state open
Review a Learning PR
bash
# View PR details
gh pr view [PR-NUMBER]

# See files changed
gh pr diff [PR-NUMBER]

# View in browser
gh pr view [PR-NUMBER] --web
Merge Valuable Learning

When learning results look good:

bash
# Merge via CLI
gh pr merge [PR-NUMBER] --merge

# Or merge via GitHub web interface for more control
gh pr view [PR-NUMBER] --web
Close Without Merging

If a learning session produced low-quality results:

bash
# Close PR without merging
gh pr close [PR-NUMBER]

# Optionally delete the branch too
gh pr close [PR-NUMBER] --delete-branch
Bulk Operations
bash
# List all open learning PRs
gh pr list --search "Learning:" --state open

# List all learning branches (including those without PRs)
git branch -r | grep "learning/"

# Delete all merged learning branches (cleanup)
git branch -r --merged main | grep "learning/" | xargs -I {} git push origin --delete {}
Why This Pattern?
  • Formal review: PRs provide structured review with descriptions and checklists
  • Main stays clean: Learning only enters main after explicit approval
  • Easy comparison: GitHub diff view shows exactly what was learned
  • Discussion: Can comment on specific insights or flag issues
  • Audit trail: PR history shows decisions about what was accepted/rejected
  • Notifications: Get notified when learning sessions complete

Integration with Other Skills

SkillRelationship
/deep-researchCore research engine (called each cycle)
/auto-discoveryCan run separately for connection-only cycles
/integrate-recent-notesRuns after learning to connect new notes
/refresh-indexCalled before each cycle
/analyze-kbRun periodically to update gap analysis

The Learning Pattern

┌────────────────────────────────────────────────────────────────────────────┐
│                          LEARNING HEARTBEAT                                 │
│                                                                             │
│  ┌────────┐   ┌────────┐   ┌────────┐   ┌────────┐   ┌─────────┐   ┌─────┐ │
│  │ SELECT │──▶│RESEARCH│──▶│EXTRACT │──▶│CONNECT │──▶│ COMMIT  │──▶│ PR  │ │
│  │ TOPIC  │   │ PAPERS │   │INSIGHTS│   │ TO KB  │   │ BRANCH  │   │     │ │
│  └────────┘   └────────┘   └────────┘   └────────┘   └─────────┘   └──┬──┘ │
│       │                                                               │     │
│       │                                                       ┌───────▼───┐ │
│       │                                                       │ RETURN TO │ │
│       │                                                       │   MAIN    │ │
│       │                                                       └─────┬─────┘ │
│       │                                                             │       │
│       └─────────────────────SLEEP 8hrs──────────────────────────────┘       │
│                                                                             │
└────────────────────────────────────────────────────────────────────────────┘

Each cycle:
1. Check gaps in knowledge base
2. Select topic (gap-fill / depth / emerging)
3. Research latest papers (15-25)
4. Extract unique insights (15-25)
5. Discover connections to existing notes
6. Commit to learning/YYYY-MM-DD-topic branch
7. Push branch, create Pull Request
8. Return to main, schedule next cycle

Continuous learning → Ever-expanding knowledge base
PRs enable formal review → Selective merging via GitHub

Completion Checklist

Each cycle should complete:

  • Topic selected with rationale
  • Research report generated (15-25 papers)
  • Session folder created in Document Insights
  • Insights extracted with deduplication
  • Connections discovered to existing notes
  • State file updated with cycle results
  • Master changelog updated
  • Learning branch created and pushed
  • Pull request created
  • Returned to main branch
  • Next cycle scheduled (if continuing)

State Dependencies

SourceLocationReadWriteDescription
State fileresources/learn-new-things-log.md✓✓Cycle tracking
KB analysisknowledge-base-analysis.md✓Gap identification
Research reportsresources/✓Generated reports
Document InsightsBrain/Document Insights/✓Extracted insights
ChangelogsBrain/05-Meta/Changelogs/✓Session logs
Master changelogBrain/CHANGELOG.md✓✓Summary entries
Local Brain Searchresources/local-brain-search/✓Index, search

Remember: This is a continuous learning engine. Each cycle makes the knowledge base smarter. The goal is not completion - it's perpetual growth and integration.

© Abilityai, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/learn-new-things of Abilityai/cornelius.

Open the folder on GitHubat commit fd5e9a4

Compare with similar skills

Learn New Things 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.

Learn New Things compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Learn New Things this skillAbilityai/cornelius109—~5kAutomated safety check: NotesMIT
New LoopAI-Builder-Club/skills1.3k—~1.2kAutomated safety check: NotesNone
Maintain Codex Wikiaiskillstore/marketplace4301 repos~2kAutomated safety check: NotesNone
Ima Knowledge Basecountbot-ai/CountBot782—~506Automated safety check: PassMIT
HypatiaMarchLiu/hypatia239—~7.9kAutomated safety check: NotesMIT
Migrateguhcostan/claude-mega-brain126—~975Automated safety check: PassMIT

Similar skills

  • New Loop

    AI-Builder-Club/skills

    Spin up a new loop (domain) in a file-based knowledge base — bootstrap the substrate if it's missing, gather the loop's charter, scaffold domains/<loop/README.md, then do ONE real test run and…

    1.3k GitHub stars~1.2k tokensUpdated 22 days ago
    Knowledge ManagementAuto-check: notes
  • Maintain Codex Wiki

    aiskillstore/marketplace

    Maintain a review-first Markdown knowledge base for Codex practices with source provenance, engineering capture, citation-aware queries, explicit archive and promotion, and deterministic linting.

    430 GitHub starsUsed in 1 repo~2k tokens
    Knowledge ManagementAuto-check: notes
  • Ima Knowledge Base

    countbot-ai/CountBot

    通过 IMA OpenAPI 处理知识库任务。支持知识库内容搜索、命中详情查看、条目浏览、列出知识库、上传文件、导入网页。用户提到知识库、资料库、上传到知识库、导入网页、搜知识库时使用。

    782 GitHub stars~506 tokensUpdated 3 days ago
    Knowledge ManagementAuto-check passed
  • Hypatia

    MarchLiu/hypatia

    Interact with the Hypatia AI memory system using natural language.

    239 GitHub stars~7.9k tokensUpdated 8 days ago
    Knowledge ManagementAuto-check: notes
  • Migrate

    guhcostan/claude-mega-brain

    Scan the project and migrate existing documentation into OKF format.

    126 GitHub stars~975 tokensUpdated 2 mo ago
    Knowledge ManagementAuto-check passed
  • Psr Autoloading Knowledge

    dykyi-roman/awesome-claude-code

    PSR-4 autoloading standard knowledge base for PHP 8.4 projects.

    103 GitHub stars~2.1k tokensUpdated 1 mo ago
    Knowledge ManagementAuto-check passed

More from Abilityai/cornelius

All 51 skills in this repo
  • Nano Banana Image Generator

    Abilityai/cornelius

    Generate images using Google's Nano Banana (Gemini 2.5 Flash Image).

    109 GitHub stars~1.2k tokensUpdated 15 days ago
    Auto-check: notes
  • Changelog Protocol

    Abilityai/cornelius

    Protocol for creating dated changelog files after significant agent sessions.

    109 GitHub stars~555 tokensUpdated 15 days ago
    Auto-check passed
  • Create Article

    Abilityai/cornelius

    Create long-form articles from knowledge base insights. An agent skill from Abilityai/cornelius.

    109 GitHub stars~2.1k tokensUpdated 15 days ago
    Auto-check: notes
  • Epistemic Classification

    Abilityai/cornelius

    Framework for distinguishing research findings from hypotheses and speculative synthesis.

    109 GitHub stars~1.5k tokensUpdated 15 days ago
    Auto-check passed
  • Get Youtube Transcript

    Abilityai/cornelius

    Extract the transcript from a YouTube video by URL or video ID.

    109 GitHub stars~525 tokensUpdated 15 days ago
    Auto-check: notes
  • Insight Capture Format

    Abilityai/cornelius

    Standard format for capturing and documenting insights in the knowledge base.

    109 GitHub stars~616 tokensUpdated 15 days ago
    Auto-check passed

Questions about Learn New Things

What does Learn New Things do?

Continuous learning heartbeat - autonomously researches, extracts insights, and expands knowledge base. Learn New Things is an agent skill from Abilityai/cornelius.

When should I use Learn New Things?

Learn New Things fits situations like: tasks that involve Knowledge bases.

How do I install Learn New Things in Claude Code?

Run `npx skills add Abilityai/cornelius --skill learn-new-things -a claude-code`. Or copy the skill folder (.claude/skills/learn-new-things in Abilityai/cornelius) into .claude/skills/learn-new-things in your project. Claude Code loads it when a task matches its description.

How do I install Learn New Things in Codex?

Run `npx skills add Abilityai/cornelius --skill learn-new-things -a codex`. Or copy the skill folder (.claude/skills/learn-new-things in Abilityai/cornelius) into .agents/skills/learn-new-things in your project. Codex loads it when a task matches its description.

Can I use Learn New Things 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 Abilityai/cornelius --skill learn-new-things -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/learn-new-things, .gemini/skills/learn-new-things, .github/skills/learn-new-things and .opencode/skills/learn-new-things in your project.

What does Learn New Things need to run?

Going by SKILL.md and its folder, Learn New Things needs the command-line tools its instructions call (git and gh). Its frontmatter pre-approves these tools: Task, Read, Write, Bash, Glob, Grep.

Does Learn New Things access the network?

SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Learn New Things safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Learn New Things use?

Learn New Things 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 Learn New Things use?

About 5k tokens (SKILL.md is roughly 20k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Learn New Things?

Skills that share tags, products or a category with Learn New Things: New Loop (AI-Builder-Club/skills, 1.3k stars), Maintain Codex Wiki (aiskillstore/marketplace, 430 stars), Ima Knowledge Base (countbot-ai/CountBot, 782 stars) and Hypatia (MarchLiu/hypatia, 239 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Learn New Things?

Abilityai (a GitHub organization) maintains it in Abilityai/cornelius, which has 109 GitHub stars. The repository holds 51 skills in this directory. The repository was last updated on September 22, 2026.

Source: Abilityai/cornelius on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.