agentleFS
Idris-MichaelIdris-Michael/hermes-os/.agents/skills/notebooklm/SKILL.md

notebooklm

Skill1 starsChanged 6 months agoMITView on GitHub

Complete API for Google NotebookLM - full programmatic access including features not in the web UI. Create notebooks, add sources, generate all artifact types, download in multiple formats. Activates on explicit /notebooklm or intent like "create a podcast about X", "install notebooklm", "add notebooklm to cowork

  • Deletes or force-pushes
  • Installs packages

69 other projects use a version of this, 24 of them edited.

Adopted by

Most recently taken up by

Used with

Projects with it also use django-verification, django-security and 10 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.
  • mstuder-slalomSkill

    django-verification

    Verification loop for Django projects: migrations, linting, tests with coverage, security scans, and deployment readiness checks before release or PR.

    Also in 3 projects that use this

  • mstuder-slalomSkill

    django-security

    Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.

    Also in 3 projects that use this

  • sirakinbSkill

    last30days

    Research a topic from the last 30 days on Reddit + X + Web, become an expert, and write copy-paste-ready prompts for the user's target tool.

    Also in 4 projects that use this

  • younghaiSkill

    google-calendar

    Google Calendar 일정 조회, 검색, 등록. "일정", "스케줄", "캘린더" 등을 언급하면 자동 실행. Daily Note 작성, Weekly Review에 사용.

    Also in 3 projects that use this

  • royaluniondesign-sysSkill

    deployment-patterns

    Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.

    Also in 3 projects that use this

  • LuisSambranoSkill

    firecrawl

    Deep web scraping, screenshots, PDF parsing, and website crawling using Firecrawl API

    Also in 3 projects that use this

The file

Show its rules and text

We split this skill into the rules it gives an agent

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

  • 0

    Common

    Most of the 66 edited versions we read keep these.

  • 11

    Distinctive

    This author's own choices. Worth a look.

  • 5

    Very specific

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

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

    When this skill is triggered and notebooklm is not yet installed or authenticated, complete setup first.

    line 22
  2. Distinctive:

    If Python is below 3.10 (e.g.

    line 32
  3. Distinctive:

    Always use a virtual environment to avoid "externally-managed-environment" errors and PATH issues.

    line 47
  4. Distinctive:

    Verify the CLI works:

    line 72
  5. Distinctive:

    Wait ~10 seconds for the browser to open, then ask the user if they can see the browser and are signed in.

    line 135
  6. Distinctive:

    If auth passes (SID cookie present), confirm to the user that NotebookLM is set up and ready.

    line 153
  7. Distinctive:

    If auth fails (SID cookie missing), the user may not have fully signed in.

    line 159
  8. Distinctive:

    When the user asks to "add this to Cowork", "use this in Cowork", or "make this work in Cowork":

    line 173
  9. Distinctive:

    If either check fails, run the Step 0: Local Setup above before continuing.

    line 205
  10. Distinctive:

    Create the project and set up a Python 3.12 virtual environment:

    line 211
  11. Very specific:

    Create ~/notebooklm-mcp/server.py.

    line 220
  12. Distinctive:

    All generate commands support:

    line 489
  13. Very specific:

    Wait for sources: notebooklm source list --json until all status=READY

    line 513
  14. Very specific:

    Check notebooklm artifact list for status

    line 515
  15. Distinctive:

    Create one permanent notebook called something like "AI Brain"

    line 525
  16. Very specific:

    After every working session, append a summary as a new source (the /wrapup skill automates this)

    line 526

“Common” is measured: kept by at least 6 in 10 of the 66 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
<!-- notebooklm-py v0.3.4 -->

NotebookLM Automation

Complete programmatic access to Google NotebookLM—including capabilities not exposed in the web UI. Create notebooks, add sources (URLs, YouTube, PDFs, audio, video, images), chat with content, generate all artifact types, and download results in multiple formats.

This skill has two setup paths:

  1. Local Claude Code — Install the notebooklm-py CLI on your Mac and authenticate. Fast, direct, no network overhead. Use this for terminal sessions.
  2. Cowork — Wrap the CLI in an MCP server, tunnel it via Cloudflare, and connect Cowork to the public HTTPS endpoint. Use this when you want NotebookLM access inside Cowork (Anthropic's sandbox can't run your local CLI directly).

The original cookie-inlining approach for Cowork has been replaced with the MCP pattern below. It's more robust (no token expiry pain), secure (credentials never leave your Mac), and works for any local CLI you want to expose to Cowork.


Step 0: Local Setup (Run Automatically on First Use)

When this skill is triggered and notebooklm is not yet installed or authenticated, complete setup first.

Pre-flight: Check Python Version

notebooklm-py requires Python 3.10+. Check the available version before installing:

python3 --version

If Python is below 3.10 (e.g. 3.9.x which is the macOS default), install a compatible version:

macOS (Homebrew):

brew install python@3.12

Then use /opt/homebrew/bin/python3.12 (Apple Silicon) or /usr/local/bin/python3.12 (Intel) for the venv below.

Linux (apt):

sudo apt update && sudo apt install -y python3.12 python3.12-venv

Install the CLI

Always use a virtual environment to avoid "externally-managed-environment" errors and PATH issues.

Determine which Python to use — if the system python3 is 3.10+, use it directly. Otherwise use the one you just installed (e.g. python3.12):

# Set PYTHON to the correct binary (adjust if needed)
PYTHON=$(command -v python3.12 2>/dev/null || command -v python3.11 2>/dev/null || command -v python3.10 2>/dev/null || command -v python3)

# Verify it's 3.10+
$PYTHON -c "import sys; assert sys.version_info >= (3,10), f'Python {sys.version} is too old — need 3.10+'; print(f'Using Python {sys.version}')"

# Create venv and install
$PYTHON -m venv ~/.notebooklm-venv
source ~/.notebooklm-venv/bin/activate
pip install "notebooklm-py[browser]"
playwright install chromium

Then symlink so it's always on PATH:

mkdir -p ~/bin
ln -sf ~/.notebooklm-venv/bin/notebooklm ~/bin/notebooklm
export PATH="$HOME/bin:$PATH"

Verify the CLI works:

notebooklm --help

Authenticate

IMPORTANT: The built-in notebooklm login command requires interactive terminal input (pressing Enter after sign-in). Claude Code's bash tool does NOT support interactive input, so notebooklm login will fail — the browser opens and closes instantly. Instead, use this custom login script.

Tell the user:

I'm going to open a browser window — just sign into your Google account and navigate to notebooklm.google.com. Take your time, I'll wait for you to confirm before closing it.

Then write and run this login script:

cat > /tmp/nlm_login.py << 'PYEOF'
import json, os, time
from pathlib import Path
from playwright.sync_api import sync_playwright

STORAGE_PATH = Path.home() / ".notebooklm" / "storage_state.json"
PROFILE_PATH = Path.home() / ".notebooklm" / "browser_profile"
SIGNAL_FILE = Path("/tmp/nlm_save_signal")

SIGNAL_FILE.unlink(missing_ok=True)
STORAGE_PATH.parent.mkdir(parents=True, exist_ok=True)

print("Opening browser for Google login...")
print("Sign in to Google and navigate to notebooklm.google.com")

with sync_playwright() as p:
    browser = p.chromium.launch_persistent_context(
        user_data_dir=str(PROFILE_PATH),
        headless=False,
        args=["--disable-blink-features=AutomationControlled"],
    )
    page = browser.pages[0] if browser.pages else browser.new_page()
    page.goto("https://notebooklm.google.com/")

    print("Browser is open. Waiting for save signal...")
    while not SIGNAL_FILE.exists():
        time.sleep(1)

    print("Save signal received! Capturing session...")
    storage = browser.storage_state()
    with open(STORAGE_PATH, "w") as f:
        json.dump(storage, f)

    cookie_names = [c["name"] for c in storage.get("cookies", [])]
    print(f"Saved {len(cookie_names)} cookies: {cookie_names}")
    browser.close()

SIGNAL_FILE.unlink(missing_ok=True)
print(f"Authentication saved to: {STORAGE_PATH}")
PYEOF

# Run the login script in the background
source ~/.notebooklm-venv/bin/activate
python3 /tmp/nlm_login.py > /tmp/nlm_login_output.txt 2>&1 &
echo "Login started (PID=$!). Browser should open in a few seconds..."

Wait ~10 seconds for the browser to open, then ask the user if they can see the browser and are signed in.

Once the user confirms they are on the NotebookLM homepage, save the session:

touch /tmp/nlm_save_signal
sleep 8
cat /tmp/nlm_login_output.txt

Then verify authentication:

export PATH="$HOME/bin:$PATH"
notebooklm auth check
notebooklm list

If auth passes (SID cookie present), confirm to the user that NotebookLM is set up and ready. Clean up the temp script:

rm -f /tmp/nlm_login.py /tmp/nlm_login_output.txt /tmp/nlm_save_signal

If auth fails (SID cookie missing), the user may not have fully signed in. Delete the browser profile and retry:

rm -rf ~/.notebooklm/browser_profile ~/.notebooklm/storage_state.json

Then run the login script again from the top.


Adding NotebookLM to Cowork (MCP Server + Cloudflare Tunnel)

Credit: This approach was contributed by Daniel at skool.com/navaigate. It supersedes the older cookie-inlining method, which broke whenever Google rotated tokens.

When the user asks to "add this to Cowork", "use this in Cowork", or "make this work in Cowork":

Why the MCP Approach

Cowork runs on Anthropic's servers. It can't see your local files. It can't run your CLI tools. The old approach of inlining auth cookies into a skill file failed repeatedly because:

  • Tokens expire and force a full regeneration cycle
  • Google's auth flow can change without warning
  • You have to re-upload the skill every time

The MCP pattern solves this cleanly: the CLI stays on your Mac (full filesystem access, full auth), you wrap it in an MCP server, Cloudflare Tunnel gives it a public HTTPS URL, and Cowork connects to that URL like any other MCP server. The agent doesn't know or care where the tool runs — it just works.

Architecture

Claude Code / Cowork
        ↓ MCP Protocol (SSE)
Cloudflare Tunnel (HTTPS)
        ↓
Your Mac — localhost:8484
        ↓
MCP Server (Python + FastMCP)
        ↓
NotebookLM CLI → Google NotebookLM

Prerequisite Check

# Make sure the local CLI is installed and authenticated first
cat ~/.notebooklm/storage_state.json > /dev/null 2>&1 && notebooklm auth check

If either check fails, run the Step 0: Local Setup above before continuing.

You'll also need a domain on Cloudflare (for the tunnel hostname). If the user doesn't have one yet, they'll need to set that up first at cloudflare.com.

Step 1: Build the MCP Server

Create the project and set up a Python 3.12 virtual environment:

mkdir -p ~/notebooklm-mcp && cd ~/notebooklm-mcp
/opt/homebrew/bin/python3.12 -m venv .venv
source .venv/bin/activate
pip install "mcp[cli]" uvicorn

Create ~/notebooklm-mcp/server.py. Every CLI command becomes a decorated Python function — here's the pattern (extend with as many tools as you want exposed):

import sys, subprocess
from mcp.server.fastmcp import FastMCP

NOTEBOOKLM = "/Users/YOUR_USERNAME/bin/notebooklm"  # adjust to your symlink path
mcp = FastMCP("notebooklm", host="0.0.0.0", port=8484)

def run_cli(*args, timeout=120):
    result = subprocess.run(
        [NOTEBOOKLM, *args],
        capture_output=True, text=True, timeout=timeout
    )
    return result.stdout.strip() or "(no output)"

@mcp.tool()
def notebooklm_list() -> str:
    """List all NotebookLM notebooks."""
    return run_cli("list")

@mcp.tool()
def notebooklm_use(notebook_id: str) -> str:
    """Set the active notebook context."""
    return run_cli("use", notebook_id)

@mcp.tool()
def notebooklm_ask(question: str) -> str:
    """Ask the current notebook a question (RAG query)."""
    return run_cli("ask", question, timeout=120)

@mcp.tool()
def notebooklm_source_add(url_or_path: str) -> str:
    """Add a URL, YouTube link, or local file as a source to the current notebook."""
    return run_cli("source", "add", url_or_path, timeout=180)

@mcp.tool()
def notebooklm_generate_audio(instructions: str = "") -> str:
    """Generate a podcast-style audio overview."""
    args = ["generate", "audio"]
    if instructions:
        args.append(instructions)
    return run_cli(*args, timeout=600)

# Follow this pattern for every command you want to expose —
# create, source list, generate video/report/quiz/flashcards, download, etc.
# See the Quick Reference table further down for the full command surface.

if __name__ == "__main__":
    if "--sse" in sys.argv:
        import uvicorn
        app = mcp.sse_app()
        uvicorn.run(app, host="0.0.0.0", port=8484)
    else:
        mcp.run(transport="stdio")

The entry point supports two transport modes:

  • SSE mode (--sse) — for Cowork via the tunnel. Runs an HTTP server on port 8484.
  • Stdio mode (default) — for local Claude Code. Direct pipe, no network overhead.

Smoke test it:

source ~/notebooklm-mcp/.venv/bin/activate
python -c "from server import run_cli; print(run_cli('auth', 'check'))"

Step 2: Set Up the Cloudflare Tunnel

Cowork runs on Anthropic's servers. localhost means nothing to it. You need a public HTTPS URL pointing at your Mac. Cloudflare Tunnel does this without opening any ports on your router.

brew install cloudflared
cloudflared tunnel login
cloudflared tunnel create notebooklm-mcp
cloudflared tunnel route dns notebooklm-mcp mcp-notebooklm.yourdomain.com

Create ~/.cloudflared/config-notebooklm-mcp.yml:

tunnel: YOUR_TUNNEL_ID
credentials-file: ~/.cloudflared/YOUR_TUNNEL_ID.json

ingress:
  - hostname: mcp-notebooklm.yourdomain.com
    service: http://localhost:8484
  - service: http_status:404

Test it end-to-end:

# Terminal 1: start the server
cd ~/notebooklm-mcp && source .venv/bin/activate
python server.py --sse

# Terminal 2: start the tunnel
cloudflared tunnel --config ~/.cloudflared/config-notebooklm-mcp.yml run notebooklm-mcp

# Terminal 3: verify
curl -s https://mcp-notebooklm.yourdomain.com/sse | head -3

You should see event: endpoint with a session ID. That means it's working.

Step 3: Auto-Start on Boot (macOS Launch Agents)

You don't want to manually start two processes every time you turn on your Mac. Create two Launch Agents:

MCP Server — ~/Library/LaunchAgents/dev.navaigate.notebooklm-mcp.plist Points to .venv/bin/python server.py --sse. Set RunAtLoad and KeepAlive to true.

Tunnel — ~/Library/LaunchAgents/dev.navaigate.notebooklm-tunnel.plist Points to cloudflared tunnel run with the config file. Same flags.

Load them once — they persist across reboots, and macOS restarts either process automatically if it crashes:

launchctl load ~/Library/LaunchAgents/dev.navaigate.notebooklm-mcp.plist
launchctl load ~/Library/LaunchAgents/dev.navaigate.notebooklm-tunnel.plist

Step 4: Connect to Cowork

  1. Open Cowork and click the + icon
  2. Go to Connectors → Add connection → Add custom connector
  3. Enter: https://mcp-notebooklm.yourdomain.com/sse
  4. Click Add

The NotebookLM tools appear immediately. Prompt naturally:

"List my NotebookLM notebooks" "Switch to my AI Brain notebook and tell me the last 3 entries" "Ask my AI Brain: what were the key decisions from last week?" "Generate a podcast from my current notebook"

Step 5: Local Claude Code Setup (Stdio Transport)

For terminal sessions you don't need the tunnel — add the MCP server to ~/.claude/settings.json using stdio transport:

{
  "mcpServers": {
    "notebooklm": {
      "command": "/Users/YOUR_USERNAME/notebooklm-mcp/.venv/bin/python",
      "args": ["/Users/YOUR_USERNAME/notebooklm-mcp/server.py"]
    }
  }
}

Same server, different transport. The tools work identically — local sessions just skip the network hop.

MCP Troubleshooting

SymptomFix
Auth expiredRun notebooklm login (or the custom login script in Step 0) locally. The MCP server picks up new tokens automatically — no restart needed.
Server not respondinglsof -i :8484 to check the port, tail ~/notebooklm-mcp/mcp-server.log for errors, then launchctl kickstart -k gui/$(id -u)/dev.navaigate.notebooklm-mcp.
Tunnel downcloudflared tunnel info notebooklm-mcp. KeepAlive usually restarts it automatically.
Cowork says "can't reach server"Verify with curl -s https://mcp-notebooklm.yourdomain.com/sse | head -3. If that works, remove and re-add the connector in Cowork.

Why This Pattern Generalizes

Local MCP server + Cloudflare Tunnel isn't just for NotebookLM. Any CLI tool, any local service, any API that needs local credentials can be wrapped as an MCP server and made available to Cowork the same way. Once you've done it once, you can do it for anything.

Resources


When This Skill Activates

Explicit: User says "/notebooklm", "use notebooklm", "install notebooklm", or mentions the tool by name.

Intent detection: Recognize requests like:

  • "Create a podcast about [topic]"
  • "Summarize these URLs/documents"
  • "Generate a quiz from my research"
  • "Turn this into an audio overview"
  • "Create flashcards for studying"
  • "Generate a video explainer"
  • "Make an infographic"
  • "Create a mind map of the concepts"
  • "Download the quiz as markdown"
  • "Add these sources to NotebookLM"
  • "Add this to Cowork" / "Make this work in Cowork" → use the MCP pattern above

Autonomy Rules

Run automatically (no confirmation):

  • notebooklm status - check context
  • notebooklm auth check - diagnose auth issues
  • notebooklm list - list notebooks
  • notebooklm source list - list sources
  • notebooklm artifact list - list artifacts
  • notebooklm language list - list supported languages
  • notebooklm language get - get current language
  • notebooklm language set - set language (global setting)
  • notebooklm artifact wait - wait for artifact completion
  • notebooklm source wait - wait for source processing
  • notebooklm research status - check research status
  • notebooklm research wait - wait for research
  • notebooklm use <id> - set context
  • notebooklm create - create notebook
  • notebooklm ask "..." - chat queries (without --save-as-note)
  • notebooklm history - display conversation history (read-only)
  • notebooklm source add - add sources

Ask before running:

  • notebooklm delete - destructive
  • notebooklm generate * - long-running, may fail
  • notebooklm download * - writes to filesystem
  • notebooklm ask "..." --save-as-note - writes a note
  • notebooklm history --save - writes a note

Quick Reference

TaskCommand
List notebooksnotebooklm list
Create notebooknotebooklm create "Title"
Set contextnotebooklm use <notebook_id>
Show contextnotebooklm status
Add URL sourcenotebooklm source add "https://..."
Add filenotebooklm source add ./file.pdf
Add YouTubenotebooklm source add "https://youtube.com/..."
List sourcesnotebooklm source list
Wait for source processingnotebooklm source wait <source_id>
Web research (fast)notebooklm source add-research "query"
Web research (deep)notebooklm source add-research "query" --mode deep --no-wait
Check research statusnotebooklm research status
Wait for researchnotebooklm research wait --import-all
Chatnotebooklm ask "question"
Chat (specific sources)notebooklm ask "question" -s src_id1 -s src_id2
Chat (with references)notebooklm ask "question" --json
Chat (save answer as note)notebooklm ask "question" --save-as-note
Show conversation historynotebooklm history
Save all history as notenotebooklm history --save
Get source fulltextnotebooklm source fulltext <source_id>
Generate podcastnotebooklm generate audio "instructions"
Generate videonotebooklm generate video "instructions"
Generate reportnotebooklm generate report --format briefing-doc
Generate quiznotebooklm generate quiz
Generate flashcardsnotebooklm generate flashcards
Generate infographicnotebooklm generate infographic
Generate mind mapnotebooklm generate mind-map
Generate slide decknotebooklm generate slide-deck
Revise a slidenotebooklm generate revise-slide "prompt" --artifact <id> --slide 0
Check artifact statusnotebooklm artifact list
Wait for completionnotebooklm artifact wait <artifact_id>
Download audionotebooklm download audio ./output.mp3
Download videonotebooklm download video ./output.mp4
Download slide deck (PDF)notebooklm download slide-deck ./slides.pdf
Download slide deck (PPTX)notebooklm download slide-deck ./slides.pptx --format pptx
Download reportnotebooklm download report ./report.md
Download mind mapnotebooklm download mind-map ./map.json
Download data tablenotebooklm download data-table ./data.csv
Download quiznotebooklm download quiz quiz.json
Download flashcardsnotebooklm download flashcards cards.json
List languagesnotebooklm language list
Set languagenotebooklm language set zh_Hans

Generation Types

All generate commands support:

  • -s, --source to use specific source(s) instead of all sources
  • --language to set output language (defaults to 'en')
  • --json for machine-readable output
  • --retry N to automatically retry on rate limits
TypeCommandOptionsDownload
Podcastgenerate audio--format [deep-dive|brief|critique|debate], --length [short|default|long].mp3
Videogenerate video--format [explainer|brief], --style [auto|classic|whiteboard|kawaii|anime|watercolor|retro-print|heritage|paper-craft].mp4
Slide Deckgenerate slide-deck--format [detailed|presenter], --length [default|short].pdf / .pptx
Slide Revisiongenerate revise-slide "prompt" --artifact <id> --slide N--wait, --notebook(re-downloads parent deck)
Infographicgenerate infographic--orientation [landscape|portrait|square], --detail [concise|standard|detailed].png
Reportgenerate report--format [briefing-doc|study-guide|blog-post|custom], --append "extra instructions".md
Mind Mapgenerate mind-map(sync, instant).json
Data Tablegenerate data-tabledescription required.csv
Quizgenerate quiz--difficulty [easy|medium|hard], --quantity [fewer|standard|more].json/.md/.html
Flashcardsgenerate flashcards--difficulty [easy|medium|hard], --quantity [fewer|standard|more].json/.md/.html

Common Workflows

Research to Podcast

  1. notebooklm create "Research: [topic]"
  2. notebooklm source add for each URL/document
  3. Wait for sources: notebooklm source list --json until all status=READY
  4. notebooklm generate audio "Focus on [specific angle]"
  5. Check notebooklm artifact list for status
  6. notebooklm download audio ./podcast.mp3 when complete

Document Analysis

  1. notebooklm create "Analysis: [project]"
  2. notebooklm source add ./doc.pdf (or URLs)
  3. notebooklm ask "Summarize the key points"
  4. Continue chatting as needed

Second-Brain Pattern (the "AI Brain" workflow)

  1. Create one permanent notebook called something like "AI Brain"
  2. After every working session, append a summary as a new source (the /wrapup skill automates this)
  3. In Cowork, add a project instruction: "Whenever answering questions about strategy, business context, or project history, always consult my NotebookLM AI Brain notebook first."
  4. Claude now checks your second brain before answering — perfect recall of everything you've ever worked on

Output Formats (--json)

// notebooklm list --json
{"notebooks": [{"id": "...", "title": "...", "created_at": "..."}]}

// notebooklm source list --json
{"sources": [{"id": "...", "title": "...", "status": "ready|processing|error"}]}

// notebooklm artifact list --json
{"artifacts": [{"id": "...", "title": "...", "type": "Audio Overview", "status": "in_progress|pending|completed|unknown"}]}

Error Handling

ErrorCauseAction
Auth/cookie errorSession expiredRe-run the login script from Step 0
"No notebook context"Context not setRun notebooklm use <id>
Rate limitingGoogle throttleWait 5-10 min, retry
Download failsGeneration incompleteCheck artifact list for status
Cowork tool calls failMCP server or tunnel downSee MCP Troubleshooting section above

Known Limitations

  • Audio, video, quiz, flashcard, infographic, and slide deck generation may fail due to Google rate limits
  • Generation times: audio 10-20 min, video 15-45 min, quiz/flashcards 5-15 min
  • This is an unofficial API — Google can change things without warning
  • The MCP server runs on your Mac, so Cowork access requires your Mac to be awake and online. For 24/7 access, deploy the server to a VPS and point the tunnel there instead.

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.