Skip to content
cccskills
FreePublished on GitHubEnglish overview

knowledge-ops

Save, organize, synchronize, and retrieve documents, conversations, and project information across local files, memory tools, knowledge repositories, and databases. Check for duplicates before storing information and choose a suitable home for each type of knowledge.

OriginalShow the original description

Knowledge base management, ingestion, sync, and retrieval across multiple storage layers (local files, MCP memory, vector stores, Git repos). Use when the user wants to save, organize, sync, deduplicate, or search across their knowledge systems.

Works withSupabase
AI rating80/ 100See how to install

Good for

  • Saving documents and conversations to a knowledge base
  • Consolidating duplicate notes
  • Synchronizing knowledge across storage systems
  • Finding saved information about a topic
  • Updating active project information in GitHub or Linear

Overview

What it does

knowledge-ops classifies documents, conversations, and project information, then stores, organizes, synchronizes, and searches them in suitable locations. It works across Claude Code memory, MCP Memory Server, Git repositories for knowledge bases, and external databases. Before saving, it searches existing information and updates matching entries rather than creating duplicates. It also maintains indexes and summaries.

When it helps

Use it when conversation records and reference materials are scattered across several places and are difficult to find later. It also helps you choose storage based on the information's purpose: ongoing plans can go in GitHub or Linear, while research worth keeping can go in a knowledge base.

Example requests

  • “Save this conversation to the knowledge base and leave a short summary.”
  • “Search my existing notes and organize overlapping information.”
  • “Find the information I have already saved about this topic.”

Notes

Depending on the destination, access to MCP memory tools, Git repositories, GitHub, Linear, Supabase, or other storage is required. API keys and passwords are removed before information is recorded in Git. Knowledge bases and archive folders must not replace the working location used for actual code changes.

This overview was written by AI (OpenAI Codex) from the public SKILL.md. Check the original below for the exact behavior.

Objective evaluation

AI rated this skill on four points using only the contents of its SKILL.md. Stars and popularity are not taken into account.

Clear instructionsIs it clear when to use it and what it does?
AGoodIt specifies saving, syncing, deduplication, and search scenarios, along with destinations for different information types.
Concrete stepsAre steps, inputs, outputs, and examples spelled out?
AGoodIt provides classification, deduplication, storage, and indexing steps, with destination paths, tool names, and completion checks.
SafetyAre sending data, deleting files, and running commands disclosed?
BPartly lackingIt requires redacting secrets, but gives no confirmation procedure for committing and pushing conversation history or updating external systems.
Easy setupDoes it need few tools or API keys, and are they documented?
BPartly lackingIt lists destinations and tools such as MCP memory and GitHub, but provides no connection setup steps.

The total counts each point as A = 25, B = 15, C = 5. Rated by AI (OpenAI Codex) as of Oct 19, 2026. Treat it as a guide and read the original before installing.

Disagree? Request a re-evaluation

Tell us which point is wrong and why. No login needed. We will check it against the SKILL.md, redo the evaluation, and show the result here.

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

Files included (1)

  • SKILL.md6.6 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

Knowledge Operations

Manage a multi-layered knowledge system for ingesting, organizing, syncing, and retrieving knowledge across multiple stores.

Prefer the live workspace model:

  • code work lives in the real cloned repos
  • active execution context lives in GitHub, Linear, and repo-local working-context files
  • broader human-facing notes can live in a non-repo context/archive folder
  • durable cross-machine memory belongs in the knowledge base, not in a shadow repo workspace

When to Activate

  • User wants to save information to their knowledge base
  • Ingesting documents, conversations, or data into structured storage
  • Syncing knowledge across systems (local files, MCP memory, Supabase, Git repos)
  • Deduplicating or organizing existing knowledge
  • User says "save this to KB", "sync knowledge", "what do I know about X", "ingest this", "update the knowledge base"
  • Any knowledge management task beyond simple memory recall

Knowledge Architecture

Layer 1: Active execution truth

  • Sources: GitHub issues, PRs, discussions, release notes, Linear issues/projects/docs
  • Use for: the current operational state of the work
  • Rule: if something affects an active engineering plan, roadmap, rollout, or release, prefer putting it here first

Layer 2: Claude Code Memory (Quick Access)

  • Path: ~/.claude/projects/*/memory/
  • Format: Markdown files with frontmatter
  • Types: user preferences, feedback, project context, reference
  • Use for: quick-access context that persists across conversations
  • Automatically loaded at session start

Layer 3: MCP Memory Server (Structured Knowledge Graph)

  • Access: MCP memory tools (create_entities, create_relations, add_observations, search_nodes)
  • Use for: Semantic search across all stored memories, relationship mapping
  • Cross-session persistence with queryable graph structure

Layer 4: Knowledge base repo / durable document store

  • Use for: curated durable notes, session exports, synthesized research, operator memory, long-form docs
  • Rule: this is the preferred durable store for cross-machine context when the content is not repo-owned code

Layer 5: External Data Store (Supabase, PostgreSQL, etc.)

  • Use for: Structured data, large document storage, full-text search
  • Good for: Documents too large for memory files, data needing SQL queries

Layer 6: Local context/archive folder

  • Use for: human-facing notes, archived gameplans, local media organization, temporary non-code docs
  • Rule: writable for information storage, but not a shadow code workspace
  • Do not use for: active code changes or repo truth that should live upstream

Ingestion Workflow

When new knowledge needs to be captured:

1. Classify

What type of knowledge is it?

  • Business decision -> memory file (project type) + MCP memory
  • Active roadmap / release / implementation state -> GitHub + Linear first
  • Personal preference -> memory file (user/feedback type)
  • Reference info -> memory file (reference type) + MCP memory
  • Large document -> external data store + summary in memory
  • Conversation/session -> knowledge base repo + short summary in memory

2. Deduplicate

Check if this knowledge already exists:

  • Search memory files for existing entries
  • Query MCP memory with relevant terms
  • Check whether the information already exists in GitHub or Linear before creating another local note
  • Do not create duplicates. Update existing entries instead.

3. Store

Write to appropriate layer(s):

  • Always update Claude Code memory for quick access
  • Use MCP memory for semantic searchability and relationship mapping
  • Update GitHub / Linear first when the information changes live project truth
  • Commit to the knowledge base repo for durable long-form additions

4. Index

Update any relevant indexes or summary files.

Sync Operations

Conversation Sync

Periodically sync conversation history into the knowledge base:

  • Sources: Claude session files, Codex sessions, other agent sessions
  • Destination: knowledge base repo
  • Generate a session index for quick browsing
  • Commit and push

Workspace State Sync

Mirror important workspace configuration and scripts to the knowledge base:

  • Generate directory maps
  • Redact sensitive config before committing
  • Track changes over time
  • Do not treat the knowledge base or archive folder as the live code workspace

GitHub / Linear Sync

When the information affects active execution:

  • update the relevant GitHub issue, PR, discussion, release notes, or roadmap thread
  • attach supporting docs to Linear when the work needs durable planning context
  • only mirror a local note afterwards if it still adds value

Cross-Source Knowledge Sync

Pull knowledge from multiple sources into one place:

  • Claude/ChatGPT/Grok conversation exports
  • Browser bookmarks
  • GitHub activity events
  • Write status summary, commit and push

Memory Patterns

# Short-term: current session context
Use TodoWrite for in-session task tracking

# Medium-term: project memory files
Write to ~/.claude/projects/*/memory/ for cross-session recall

# Long-term: GitHub / Linear / KB
Put active execution truth in GitHub + Linear
Put durable synthesized context in the knowledge base repo

# Semantic layer: MCP knowledge graph
Use mcp__memory__create_entities for permanent structured data
Use mcp__memory__create_relations for relationship mapping
Use mcp__memory__add_observations for new facts about known entities
Use mcp__memory__search_nodes to find existing knowledge

Best Practices

  • Keep memory files concise. Archive old data rather than letting files grow unbounded.
  • Use frontmatter (YAML) for metadata on all knowledge files.
  • Deduplicate before storing. Search first, then create or update.
  • Prefer one canonical home per fact set. Avoid parallel copies of the same plan across local notes, repo files, and tracker docs.
  • Redact sensitive information (API keys, passwords) before committing to Git.
  • Use consistent naming conventions for knowledge files (lowercase-kebab-case).
  • Tag entries with topics/categories for easier retrieval.

Quality Gate

Before completing any knowledge operation:

  • no duplicate entries created
  • sensitive data redacted from any Git-tracked files
  • indexes and summaries updated
  • appropriate storage layer chosen for the data type
  • cross-references added where relevant

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

accessibility

FreeSummaryAI rating 100

Design and audit interfaces for Web, iOS, and Android using WCAG 2.2 accessibility guidance. Check screen-reader labels, keyboard navigation, contrast, and control sizes to identify barriers and guide implementation for people using assistive technology.

  • Adding descriptive labels to icon-only buttons
  • Reviewing keyboard navigation and modal focus
  • Checking contrast and control sizes
affaan-m/ECC284.2KUpdated Oct 20, 2026

agent-architecture-audit

FreeSummaryAI rating 80

Investigate unreliable AI agents across 12 layers, including instructions, memory, tool execution, and display. Use code and logs to trace failures, rank findings by severity, and produce an ordered repair plan that prioritizes code changes.

  • Investigating failures that appear only inside an agent application
  • Tracing old conversation content leaking into new sessions
  • Checking skipped or falsely claimed tool execution
affaan-m/ECC284.2KUpdated Oct 20, 2026

agent-eval

FreeSummaryAI rating 80

Compare coding agents on tasks from your own codebase. Define success checks, run agents in separate Git working directories, and report pass rates, available API costs, completion time, and consistency across repeated trials.

  • Comparing coding agents on real development tasks
  • Evaluating a new tool or model before adoption
  • Checking performance after agent updates
affaan-m/ECC284.2KUpdated Oct 20, 2026

agent-harness-construction

FreeSummaryAI rating 100

Design and refine an AI agent’s available actions, tool inputs, and result formats. Define recovery steps for errors, manage the information kept in context, and evaluate changes through completion rates, retries, and cost per successful task.

  • Define an AI agent’s tool set and input formats
  • Make tool results and next steps easier to interpret
  • Specify safe retries and stopping conditions
affaan-m/ECC284.2KUpdated Oct 20, 2026

agent-introspection-debugging

FreeSummaryAI rating 100

Diagnose AI agent runs that fail repeatedly, loop through tools, or lose track of the task. Capture errors and environment details, test a focused recovery action, and produce a report explaining the evidence and outcome.

  • Diagnosing repeated failures in an agent run
  • Investigating loops through the same tool calls
  • Reviewing output degradation as context grows
affaan-m/ECC284.2KUpdated Oct 5, 2026

agent-introspection-debugging

FreeSummaryAI rating 100

Diagnose failed AI agent runs by capturing errors, checking likely causes, and choosing small, reversible recovery actions. The workflow produces a structured report of the failure, recovery steps, and evidence, helping explain repeated retries or stalled progress.

  • Diagnosing repeated tool calls with no progress
  • Investigating quality loss as context grows
  • Checking file paths and environment mismatches
affaan-m/ECC284.2KUpdated Oct 20, 2026

See all skills by affaan-m

Report a problem with this skill