agentleFS
TakaGotoTakaGoto/rag-learning-academy/.claude/skills/compare/SKILL.md

compare

Skill24 starsChanged 19 days agoMITView on GitHub

Compare two RAG approaches side by side

17 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use create, optimize and 4 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • MicrosoftSkill

    create

    Also in 3 projects that use this

  • aakash-dharSkill

    optimize

    Analyzes code for performance issues including slow algorithms, memory leaks, unnecessary re-renders, database query problems, and resource bottlenecks. Use when the user says "this is slow", "optimize this", "performance issue", "why is this taking so long?", or "make this faster".

    Also in 4 projects that use this

  • AnthropicSkill

    analyze

    Answer data questions -- from quick lookups to full analyses. Use when looking up a single metric, investigating what's driving a trend or drop, comparing segments over time, or preparing a formal data report for stakeholders.

    Also in 3 projects that use this

  • OpenAISkill

    audit

    Audit or critique a product flow, journey, workflow, funnel, onboarding path, checkout path, settings path, screen, or multi-step product experience by capturing screenshots first, then reporting UX, design, and accessibility findings inline from that evidence. Use Figma only when the user explicitly asks for a board. Use when the user asks to audit, review, critique, inspect, assess, analyze, evaluate, or give feedback on a product experience.

    Also in 6 projects that use this

  • MicrosoftSkill

    report

    Turn an exploration (threads, findings, charts) into a single Markdown report — note, blog post, executive summary, KPI dashboard, slide brief, or multi-section analytical report, with embedded charts.

    Also in 3 projects that use this

  • NVIDIASkill

    research

    Before designing a feature, research how comparable libraries solve the problem, check best practices, known pitfalls, and upstream changes. Use when starting a new feature, investigating an unfamiliar area, or the user asks to research something.

    Also in 3 projects that use this

The file

We split this skill into the rules it gives an agent

6 rules. 0 are common, 4 are distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 16 edited versions we read keep these.

  • 4

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    If the user specifies two approaches (e.g., /compare fixed vs semantic chunking), use those.

    line 12
  2. Distinctive:

    Ask the learner to pick one or suggest their own comparison.

    line 39
  3. Distinctive:

    Don't just describe the differences.

    line 82
  4. Very specific:

    If the learner has their own data in src/ or sandbox/, use that.

    line 103
  5. Distinctive:

    Run the same set of test queries through each

    line 109
  6. Distinctive:

    Use concrete numbers and examples, not vague qualitative claims

    line 126

“Common” is measured: kept by at least 6 in 10 of the 16 edited versions of this file we could read. “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

Compare: Side-by-Side RAG Approach Analysis

Provide structured, balanced comparisons of RAG approaches so learners can make informed decisions for their pipelines.

Step 1: Identify What to Compare

If the user specifies two approaches (e.g., /compare fixed vs semantic chunking), use those. Otherwise, present common comparison topics:

Chunking Strategies

  • Fixed-size vs. semantic chunking
  • Sentence-based vs. paragraph-based
  • Recursive character vs. document-structure aware

Vector Databases

  • Chroma vs. Pinecone vs. Weaviate vs. Qdrant
  • In-memory vs. hosted vs. self-hosted
  • FAISS vs. purpose-built vector DBs

Search Methods

  • Dense (vector) vs. sparse (BM25) vs. hybrid
  • Single-stage vs. two-stage (retrieve + re-rank)
  • Keyword vs. semantic vs. hybrid search

Embedding Models

  • OpenAI embeddings vs. open-source (sentence-transformers)
  • Small vs. large embedding models
  • Domain-specific vs. general-purpose embeddings

Architecture Patterns

  • Naive RAG vs. advanced RAG vs. modular RAG
  • Single-hop vs. multi-hop retrieval
  • RAG vs. fine-tuning vs. long-context models

Ask the learner to pick one or suggest their own comparison.

Step 2: Present the Structured Comparison

For each approach, cover these dimensions in a clear side-by-side format:

Concept Overview

Explain each approach in 2-3 sentences. What is it and how does it work?

How It Works (Technical Detail)

Describe the mechanism. Include a short code snippet or pseudocode for each.

Pros and Cons Table

| Dimension        | Approach A        | Approach B        |
|------------------|-------------------|-------------------|
| Ease of setup    | ...               | ...               |
| Performance      | ...               | ...               |
| Scalability      | ...               | ...               |
| Cost             | ...               | ...               |
| Flexibility      | ...               | ...               |
| Maintenance      | ...               | ...               |

Performance Characteristics

Discuss latency, throughput, accuracy trade-offs with concrete numbers or ranges where possible.

Code Examples

Provide a minimal working code example for each approach so the learner can see the practical difference.

Step 3: Decision Framework

Help the learner decide which approach fits their situation:

  • Choose A when: [specific scenarios]
  • Choose B when: [specific scenarios]
  • Consider combining both when: [specific scenarios]

Frame this as trade-offs, not absolute recommendations. The right choice depends on the use case.

Step 4: Live Side-by-Side Demo

Don't just describe the differences. Show them. Using the learner's sample data (or the sandbox data if available):

  1. Run both approaches on the same 3 queries and display results side by side:
Query: "How does chunking affect retrieval?"

Fixed Chunking (256 tokens)          | Semantic Chunking
-------------------------------------|--------------------------------------
Result 1 (0.89): "...chunking is     | Result 1 (0.94): "Chunking strategy
the process of splitting documents   | directly impacts retrieval quality.
into smaller..."                     | Bad splits destroy context and..."
                                     |
Result 2 (0.82): "...overlap of 50   | Result 2 (0.91): "The ideal chunk
tokens helps preserve context at..." | is a self-contained unit of..."
  1. Highlight the differences: "Notice how semantic chunking found a more complete answer as result 1? That's because it split on topic boundaries instead of character count."
  2. Show the numbers: retrieval scores, chunk counts, any measurable difference.

If the learner has their own data in src/ or sandbox/, use that. Otherwise, generate a small sample dataset that makes the differences visible.

Step 5: DIY Experiment

Suggest a quick experiment the learner can run to extend the comparison:

  1. Set up both approaches with minimal code
  2. Run the same set of test queries through each
  3. Compare results on relevancy, latency, and output quality
  4. Draw their own conclusions

Step 6: Key Takeaway

Summarize the comparison in one or two sentences that capture the essential trade-off. For example: "Fixed chunking is simpler and faster to set up, but semantic chunking preserves meaning boundaries — start with fixed, switch to semantic when you see context-boundary issues."

Suggest 2-3 relevant next steps using slash commands:

  • /build — implement the approach you chose and see it in action
  • /architecture — design a full RAG architecture using the approach that fits your use case
  • /benchmark — benchmark both approaches with your own data to confirm the trade-offs

Guidelines

  • Stay balanced — do not push one approach over another without justification
  • Use concrete numbers and examples, not vague qualitative claims
  • Acknowledge that best practices evolve as the field moves fast
  • Connect the comparison back to the learner's current project when possible

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.