{"data":{"items":[{"id":"7412c020-d4d0-4b72-9184-e52357ec1654","excerpt":"My Dream Setup: How I Gave My Claude Code Persistent Memory, a Self-Updating Life Dashboard, and an Autonomous Thinking Loop That Ingests All of My Inboxes and Calendars, Thinks Every Hour, and Automatically Briefs Me AND Itself Every New Session. No Third-Party Tools Required! — Got the Max plan and looking for ways t","url":"https://www.reddit.com/r/ClaudeCode/comments/1rw717v/my_dream_setup_how_i_gave_my_claude_code/","role":"pain","weight":1.3577365,"occurredAt":"2026-03-17T13:48:22.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeCode","intent":"feature_request","painScore":0.45941204,"sentiment":-0.26027396,"confidence":0.9303311,"matchedPatterns":["doesnt_work","free_tier","missing_feature","manual_process","urgent"],"statement":"# Health checking A separate script ( ) validates the whole system: * Checks for stale files and missing front-matter * Enforces size budget violations * Validates routing triggers in CLAUDE.md * Runs on session start so you always know if…","title":"My Dream Setup: How I Gave My Claude Code Persistent Memory, a Self-Updating Life Dashboard, and an Autonomous Thinking Loop That Ingests All of My Inboxes and Calendars, Thinks Every Hour, and Automatically Briefs Me AND Itself Every New Session. No Third-Party Tools Required!","body":"Got the Max plan and looking for ways to burn through all that usage in a truly useful way? Here you go.\n\nI posted here recently about using Claude Code's remote server mode from your phone. A few people asked how I have MCP servers pulling in Gmail, Calendar, Slack, etc. That part is simple (first-party connectors, two commands). But what I've built on top of it is a full life assistant system, and I want to share the whole thing so anyone can replicate it.\n\n**What this actually builds:**\n\nA Claude that never forgets you. It reads your email, calendar, Slack, and iMessages every hour. It thinks about what's going on in your life, tracks your projects and relationships, notices patterns, and writes down its reasoning. When you open any Claude Code session, it already knows your world. It knows who you're working with, what deadlines are coming, what emails need replies, what happened in your meetings, and what it would advise you to focus on today. It also learns your preferences over time by tracking what suggestions you accept or reject. And if you want, it powers a dashboard on your screen that shows you everything it knows at a glance, with buttons to act on things and a way to talk back to it between cycles. It's a personal assistant that actually knows your life, runs entirely on your machine, and gets smarter every day.\n\n**Before you scroll past:**\n\n* Zero third-party AI wrappers, zero Telegram bots, zero sketchy bridges\n* The core system (memory + scheduled tasks) is all first-party Anthropic tools + plain Python with zero pip dependencies. The optional dashboard (Layer 4) does use Flask and npm packages, but those are well-known, widely-trusted libraries.\n* All memory and thinking is stored in plain English markdown files, not some opaque database you can't inspect\n* Your data stays on your machine\n* The \"database\" is a disposable cache that rebuilds from your files in seconds\n* Minimal by design. I specifically avoided adding complexity wherever I could because I'm not a developer and I need to be able to understand and trust every piece of it.\n\nI'm a filmmaker and editor. I built all of this by talking to Claude Code over the course of a few months. Every piece described here was built collaboratively in conversation. If I can do it, you can do it.\n\n**One important design choice:**\n\nI use a single unified workspace folder for everything (mine is `~/Documents/Claude/`). One folder, one [CLAUDE.md](http://CLAUDE.md), one `memory/` directory. I don't use separate project folders with separate CLAUDE.md files the way some people do. This is what makes the whole system work as a unified life assistant rather than isolated per-project memory. Every session opens in the same folder, sees the same CLAUDE.md, and has access to the full memory system regardless of what I'm working on. The CLAUDE.md itself acts as a lightweight routing index rather than a giant blob of context. It has summary tables and pointers like \"for full details, read memory/projects/atlas.md.\" Claude only loads the detail files when it actually needs them, which keeps token usage efficient instead of dumping your entire life into every session upfront.\n\nHere's the full architecture. You could paste this entire post into a Claude Code session and say \"build this for me\" and it would understand what to do.\n\n# THE LAYERS\n\nThere are four layers to this system. Each one works independently, and each one makes the next one more powerful.\n\n* **Layer 1: MCP Connectors** \\-- gives Claude eyes into your life\n* **Layer 2: Persistent Memory System** \\-- gives Claude continuity across sessions\n* **Layer 3: Scheduled Tasks (3 total)** \\-- gives Claude a heartbeat (it wakes up, thinks, and goes back to sleep)\n* **Layer 4: Command Center Dashboard (optional)** \\-- gives YOU a screen to see everything Claude knows\n\n# LAYER 1: MCP CONNECTORS\n\n**You plug Claude into your real accounts (Gmail, Calendar, Slack) so it can actually see your life. Two commands and a browser login. That's it.**\n\nClaude Code has first-party connectors for Gmail, Google Calendar, and Slack. In your terminal run:\n\n    claude mcp add-oauth\n\nIt walks you through adding the official connectors. You authenticate via Google/Slack OAuth in your browser and you're done. No API keys, no self-hosting.\n\n**What you get:**\n\n* Search your inbox, read emails, create drafts\n* List and create calendar events\n* Read Slack channels, send messages\n* All natively through tool calls\n\n**macOS bonus:** You also get access to local Apple services through AppleScript/JXA. Claude Code can run osascript commands to pull iMessages, Apple Reminders, and Apple Notes directly from your Mac. No MCP server needed, it's just a shell command. My scheduled task uses this to pull recent iMessages and incomplete reminders alongside everything else.\n\n**Optional:** For Google Docs/Sheets/Drive, I use a community MCP server (`google-docs-mcp` npm package) which needs a Google Cloud project for OAuth. A bit more setup but still straightforward. That one is separate from the life assistant system though.\n\nIf `add-oauth` doesn't look familiar, just tell Claude Code \"I want to add the official Gmail and Google Calendar MCP servers\" and it will walk you through it.\n\n# LAYER 2: PERSISTENT MEMORY SYSTEM\n\n**Claude normally forgets everything between sessions. This layer gives it a long-term memory made of simple text files that it can search through. Stuff you use a lot stays prominent. Stuff you stop caring about naturally fades away. And it all happens automatically before you even type your first message.**\n\nThis is the core of everything. It's a folder of markdown files with a Python search engine on top.\n\n# How it works\n\nYour knowledge lives in plain markdown files. Here's the full directory structure:\n\n    Claude/\n    ├── CLAUDE.md              # Routing index\n    ├── TASKS.md               # Active tasks\n    │\n    └── memory/\n        ├── memory_engine.py   # Search engine\n        ├── memory_check.py    # Health validator\n        ├── memory_maintain.sh # Daily maintenance\n        ├── memory_hook.sh     # Pre-message hook\n        ├── _inject_alerts.py  # Alert injection\n        ├── SETUP.md           # Bootstrap guide\n        │\n        ├── assistant/         # Auto-generated\n        │   ├── thinking.md    # Reasoning chain\n        │   ├── briefing.md    # Session primer\n        │   ├── patterns.md    # Feedback stats\n        │   ├── relationships.md # People graph\n        │   └── timeline.md    # Event log\n        │\n        ├── people/            # One per person\n        │   ├── sarah-chen.md\n        │   └── ...\n        │\n        ├── projects/          # One per project\n        │   ├── project-atlas.md\n        │   └── ...\n        │\n        ├── tools/             # Tool guides\n        ├── health/            # Wellness (optional)\n        ├── meetings/          # Meeting notes\n        │\n        ├── extraction/        # Transcript extractor\n        │   ├── parse_sessions.py\n        │   ├── extraction_prompt.md\n        │   ├── session_markers.json\n        │   └── .last_extraction\n        │\n        ├── hooks/             # Hook scripts\n        │   ├── session_start.sh\n        │   ├── session_end.sh\n        │   └── pre_compact.sh\n        │\n        ├── glossary.md        # Terms\n        ├── clients.md         # Clients\n        ├── tools.md           # Tool overview\n        └── status.md          # Session handoff\n\nCreate all directories during bootstrap, even if empty. The engine scans them automatically.\n\nEach file has front-matter with a verified date, scope description, and salience score:\n\n    <!-- verified: 2026-03-10 | scope: Sarah Chen - Lead Designer at Acme Co | salience: 2.30 | hits: 15 -->\n    <!-- keywords: sarah, designer, acme, lead, creative team -->\n\nA Python script (`memory_engine.py`, about 870 lines, zero pip dependencies) builds a SQLite + FTS5 full-text search index over all of these files. It splits each file into chunks at `##` headings so searches return relevant sections, not entire documents.\n\n# Implementation notes (for the Claude building this)\n\nThese are the non-obvious gotchas we've hit. If you're the Claude building this system, read these carefully:\n\n* **Hook stdin format:** Claude Code passes hook data as JSON on stdin (`{\"prompt\": \"user's message\"}`), NOT as a command-line argument. The hook script needs to parse stdin with `python3 -c \"import sys,json; print(json.load(sys.stdin).get('prompt',''))\"`. If you get this wrong, the hook silently does nothing.\n* **FTS5 query sanitization:** FTS5 chokes on punctuation (periods, colons, slashes). You MUST strip non-alphanumeric characters before passing queries to FTS5, or normal searches will crash.\n* **FTS5 ranking is negative:** FTS5 returns negative rank values (more negative = more relevant). Multiply rank by -1 before multiplying by salience, or your results will be inverted.\n* **FTS5 tokenizer:** Use `tokenize='porter unicode61'` for stemmed search. This means searching \"running\" also matches \"run.\"\n* **DB location testing:** SQLite WAL mode doesn't work on all filesystems. The engine should try `~/.cache/memory-engine/` first, verify SQLite actually works there by creating a test table, and fall back to the script directory if it fails.\n* **Hook scripts in subdirectory:** Scripts in `hooks/` need `SCRIPT_DIR=\"$(cd \"$(dirname \"$0\")/..\" && pwd)\"` (go UP one level) to find the engine. The pre-message hook in `memory/` uses `SCRIPT_DIR=\"$(cd \"$(dirname \"$0\")\" && pwd)\"` (current level). Getting this wrong means nothing can find `memory_engine.py`.\n* **Front-matter backward compatibility:** The regex must handle both the basic format (`<!-- verified: DATE | scope: DESC -->`) and the extended format (`<!-- verified: DATE | scope: DESC | salience: X.XX | hits: N -->`). Old files without salience fields should default to 1.0, not crash.\n* **Keyword enrichment display:** Keywords get appended to chunk content as `\\n[keywords: ...]` for search indexing, but MUST be stripped before displaying in context blocks. Check for `\\n[keywords:` and truncate there.\n* **Salience value guards:** Always cap salience at 5.0 and guard hit counts against corrupted values (cap at 10000). We had a bug where a huge number got written to front-matter and broke the whole system.\n* **Flush uses MAX not AVG:** When flushing salience back to files, take the MAX salience across a file's chunks and SUM the access counts. If you average salience, scores get diluted because most chunks in a file are never directly accessed.\n* **macOS vs Linux stat:** The maintenance script checks briefing freshness using file modification time. macOS uses `stat -f %m`, Linux uses `stat -c %Y`. Handle both with a `uname` check.\n* **Context block also includes recent memories:** The inject function should return both FTS5 search results AND the most recently-accessed memories (deduplicated). This provides continuity from the last session, not just keyword relevance.\n* [**CLAUDE.md**](http://CLAUDE.md) **always at max salience:** When indexing [CLAUDE.md](http://CLAUDE.md), set its salience to the cap (5.0) so it always appears in relevant results. It's your routing index and should never decay.\n\n# Salience scoring (this is what makes it alive)\n\n**Think of it like your own brain. Stuff you think about often stays sharp. Stuff you haven't thought about in months gets fuzzy. That's what salience does for Claude's memory. Important things float to the top, forgotten things sink, and if you bring something back up it snaps right back into focus.**\n\nEvery memory starts at salience 1.0. When it shows up in a search result, it gets a +0.1 boost (capped at 5.0). Every day, it decays:\n\n* **Semantic memories** (people, tools, glossary): lose 2% per day. Takes \\~110 days to go dormant.\n* **Episodic memories** (projects, status, sessions): lose 6% per day. Takes \\~37 days to go dormant.\n\n**Dormant** means below 0.1. The memory still exists in your files, it just stops appearing ","offTopic":true},{"id":"2d09256e-7de4-499a-bd35-9dd5777fd963","excerpt":"25 Claude Code Tips from 11 Months of Intense Use — [My previous post with 10 tips](https://www.reddit.com/r/ClaudeAI/comments/1qcan9z/my_top_10_claude_code_tips_from_11_months_of/) was well-received, so I decided to expand it to 25 here.\n\nThe GitHub repo: [https://github.com/ykdojo/claude-code-tips](https://github.com","url":"https://www.reddit.com/r/ClaudeAI/comments/1qgccgs/25_claude_code_tips_from_11_months_of_intense_use/","role":"request","weight":1.308981,"occurredAt":"2026-01-18T16:03:13.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"feature_request","painScore":0.31887248,"sentiment":0.66887414,"confidence":0.9925,"matchedPatterns":["doesnt_work","missing_feature","manual_process","praise"],"statement":"If something's missing, ask for edits: Then start a fresh conversation.","title":"25 Claude Code Tips from 11 Months of Intense Use","body":"[My previous post with 10 tips](https://www.reddit.com/r/ClaudeAI/comments/1qcan9z/my_top_10_claude_code_tips_from_11_months_of/) was well-received, so I decided to expand it to 25 here.\n\nThe GitHub repo: [https://github.com/ykdojo/claude-code-tips](https://github.com/ykdojo/claude-code-tips)\n\n# Tip 0: Customize your status line\n\nYou can customize the status line at the bottom of Claude Code to show useful info. I set mine up to show the model, current directory, git branch (if any), uncommitted file count, sync status with origin, and a visual progress bar for token usage. It also shows a second line with my last message so I can see what the conversation was about:\n\n    Opus 4.5 | 📁claude-code-tips | 🔀main (scripts/context-bar.sh uncommitted, synced 12m ago) | ██░░░░░░░░ 18% of 200k tokens\n    💬 This is good. I don't think we need to change the documentation as long as we don't say that the default color is orange el...\n\nThis is especially helpful for keeping an eye on your context usage and remembering what you were working on. The script also supports 10 color themes (orange, blue, teal, green, lavender, rose, gold, slate, cyan, or gray).\n\nTo set this up, you can use [this sample script](https://github.com/ykdojo/claude-code-tips/blob/main/scripts/context-bar.sh) and check the [setup instructions](https://github.com/ykdojo/claude-code-tips/blob/main/scripts/README.md).\n\n# Tip 1: Learn a few essential slash commands\n\nThere are a bunch of built-in slash commands (type `/` to see them all). Here are a few worth knowing:\n\n# /usage\n\nCheck your rate limits:\n\n     Current session\n     ███████                                            14% used\n     Resets 3:59pm (Asia/Tokyo)\n    \n     Current week (all models)\n     █████████████                                      26% used\n     Resets Jan 3, 2026, 5:59am (Asia/Tokyo)\n\nIf you want to watch your usage closely, keep it open in a tab and use Tab then Shift+Tab or ← then → to refresh.\n\n# /chrome\n\nToggle Claude's native browser integration:\n\n    > /chrome\n    Chrome integration enabled\n\n# /mcp\n\nManage MCP (Model Context Protocol) servers:\n\n     Manage MCP servers\n     1 server\n    \n     ❯ 1. playwright  ✔ connected · Enter to view details\n    \n     MCP Config locations (by scope):\n      • User config (available in all your projects):\n        • /Users/yk/.claude.json\n\n# /stats\n\nView your usage statistics with a GitHub-style activity graph:\n\n          Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec\n          ·············································▒▒▒▓▒░█\n      Mon ··············································▒█░▓░█\n          ·············································▒▒██▓░█\n      Wed ·············································░▒█▒▓░█\n          ············································░▓▒█▓▓░\n      Fri ············································░▓░█▓▓█\n          ············································▓▒░█▓▒█\n    \n          Less ░ ▒ ▓ █ More\n    \n      Favorite model: Opus 4.5        Total tokens: 12.1m\n    \n      Sessions: 1.8k                  Longest session: 20h 40m 45s\n      Current streak: 44 days         Longest streak: 45 days\n      Active days: 49/51              Peak hour: 17:00-18:00\n    \n      You've used ~145x more tokens than Brave New World\n\n# /clear\n\nClear the conversation and start fresh.\n\n# Tip 2: Talk to Claude Code with your voice\n\nI found that I can communicate much faster with my voice than typing with my hands. Using a voice transcription system on your local machine is really helpful for this.\n\nOn my Mac, I've tried a few different options:\n\n* superwhisper\n* MacWhisper\n* [Super Voice Assistant](https://github.com/ykdojo/super-voice-assistant)\n\nYou can get more accuracy by using a hosted service, but I found that a local model is strong enough for this purpose. Even when there are mistakes or typos in the transcription, Claude is smart enough to understand what you're trying to say. Sometimes you need to say certain things extra clearly, but overall local models work well enough.\n\nFor example, Claude was able to interpret mistranscribed words like \"ExcelElanishMark\" and \"advast\" correctly as \"exclamation mark\" and \"Advanced\".\n\nA common objection is \"what if you're in a room with other people?\" I just whisper using earphones - I personally like Apple EarPods (not AirPods). They're affordable, high quality enough, and you just whisper into them quietly. I've done it in front of other people and it works well. In offices, people talk anyway - instead of talking to coworkers, you're talking quietly to your voice transcription system. I don't think there's any problem with that. This method works so well that it even works on a plane. It's loud enough that other people won't hear you, but if you speak close enough to the mic, your local model can still understand what you're saying. (In fact, I'm writing this very paragraph using that method on a flight.)\n\n# Tip 3: Break down large problems into smaller ones\n\nThis is one of the most important concepts to master. It's exactly the same as traditional software engineering - the best software engineers already know how to do this, and it applies to Claude Code too.\n\nIf you find that Claude Code isn't able to one-shot a difficult problem or coding task, ask it to break it down into multiple smaller issues. See if it can solve an individual part of that problem. If it's still too hard, see if it can solve an even smaller sub-problem. Keep going until everything is solvable.\n\nEssentially, instead of going from A to B directly, you can go from A to A1 to A2 to A3, then to B.\n\nA good example of this is when I was building my own voice transcription system. I needed to build a system that could let the user select and download a model, take keyboard shortcuts, start transcribing, put the transcribed text at the user's cursor, and wrap all of this in a nice UI. That's a lot. So I broke it down into smaller tasks. First, I created an executable that would just download a model, nothing else. Then I created another one that would just record voice, nothing else. Then another one that would just transcribe pre-recorded audio. I completed them one by one like that before combining them at the end.\n\nHighly related to this: your problem-solving skills and software engineering skills are still highly relevant in the world of agentic coding and Claude Code. It's able to solve a lot of problems on its own, but when you apply your general problem-solving and software engineering skills to it, it becomes a lot more powerful.\n\n# Tip 4: Using Git and GitHub CLI like a pro\n\nJust ask Claude to handle your Git and GitHub CLI tasks. This includes committing (so you don't have to write commit messages manually), branching, pulling, and pushing.\n\nI personally allow pull automatically but not push, because push is riskier - it doesn't contaminate the origin if something goes wrong with a pull.\n\nFor GitHub CLI (`gh`), there's a lot you can do. One thing I started doing more after using Claude Code is creating draft PRs. This lets Claude Code handle the PR creation process with low risk - you can review everything before marking it ready for review.\n\nAnd it turns out, `gh` is pretty powerful. You can even send arbitrary GraphQL queries through it. For example, you can even find the exact times at which GitHub PR descriptions were edited:\n\n    ⏺ Bash(gh api graphql -f query='\n          query {\n            repository(owner: \"...\", name: \"...\") {\n              pullRequest(number: ...) {\n                userContentEdits(first: 100) {\n                  nodes { editedAt editor { login } }\n                }\n              }\n            }\n          }')\n    \n    ⏺ Here's the full edit history for your PR description:\n    \n      | #  | Edited At (UTC)     | Editor |\n      |----|---------------------|--------|\n      | 1  | 2025-12-01 00:08:34 | ykdojo |\n      | 2  | 2025-12-01 15:57:21 | ykdojo |\n      | 3  | 2025-12-01 16:24:33 | ykdojo |\n      | 4  | 2025-12-01 16:27:00 | ykdojo |\n      | 5  | 2025-12-04 00:40:02 | ykdojo |\n      ...\n\n# Tip 5: AI context is like milk; it's best served fresh and condensed!\n\nWhen you start a new conversation with Claude Code, it performs the best because it doesn't have all the added complexity of having to process the previous context from earlier parts of the conversation. But as you talk to it longer and longer, the context gets longer and the performance tends to go down.\n\nSo it's best to start a new conversation for every new topic, or if the performance starts to go down.\n\n# Tip 6: Getting output out of your terminal\n\nSometimes you want to copy and paste Claude Code's output, but copying directly from the terminal isn't always clean. Here are a few ways to get content out more easily:\n\n* **Clipboard directly**: On Mac or Linux, ask Claude to use `pbcopy` to send output straight to your clipboard\n* **Write to a file**: Have Claude put the content in a file, then ask it to open it in VS Code (or your favorite editor) so you can copy from there. You can also specify a line number, so you can ask Claude to open the specific line it just edited. For markdown files, once it's open in VS Code, you can use Cmd+Shift+P (or Ctrl+Shift+P on Linux/Windows) and select \"Markdown: Open Preview\" to see the rendered version\n* **Opening URLs**: If there's a URL you want to examine yourself, ask Claude to open it in your browser. On Mac, you can ask it to use the `open` command, but in general asking to open in your favorite browser should work on any platform\n* **GitHub Desktop**: You can ask Claude to open the current repo in GitHub Desktop. This is particularly useful when it's working in a non-root directory - for example, if you asked it to create a git worktree in a different directory and you haven't opened Claude Code from there yet\n\nYou can combine some of these together too. For example, if you want to edit a GitHub PR description, instead of having Claude edit it directly (which it might mess up), you can have it copy the content into a local file first. Let it edit that, check the result yourself, and once it looks good, have it copy and paste it back into the GitHub PR. That works really well. Or if you want to do that yourself, you can just ask it to open it in VS Code or give it to you via pbcopy so you can copy and paste it manually.\n\nOf course, you can run these commands yourself, but if you find yourself doing it repetitively, it's helpful to let Claude run them for you.\n\n# Tip 7: Set up terminal aliases for quick access\n\nSince I use the terminal more because of Claude Code, I found it helpful to set up short aliases so I can launch things quickly. Here are the ones I use:\n\n* `c` for Claude Code (this is the one I use the most)\n* `ch` for Claude Code with Chrome integration\n* `gb` for GitHub Desktop\n* `co` for VS Code\n* `q` for going to the project directory where I have most projects. From there I can manually cd into an individual folder to work on that project, or I can just launch Claude Code with `c` to let it basically have access to any project it needs to access.\n\nTo set these up, add lines like this to your shell config file (`~/.zshrc` or `~/.bashrc`):\n\n    alias c='claude'\n    alias ch='claude --chrome'\n    alias gb='github'\n    alias co='code'\n    alias q='cd ~/Desktop/projects'\n\nOnce you have these aliases, you can combine them with flags: `c -c` continues your last conversation, and `c -r` shows a list of recent conversations to resume. These work with `ch` too (`ch -c`, `ch -r`) for Chrome sessions.\n\n# Tip 8: Proactively compact your context\n\nThere's a `/compact` command in Claude Code that summarizes your conversation to free up context space. Automatic compaction also happens when the full available context is filled. The total available context window for Opus 4.5 is currently 200k, and 45k of that is reserved for automatic compaction. About 10% of the total 200k is automatically filled with the system prompt, tools, memory, and dy","offTopic":true},{"id":"d75f3d0d-a589-4860-894f-3c27c7d5f157","excerpt":"You can now create your own MCP for your Lovable app in minutes. Complete guide —   \n  \nLovable shipped \"agent integrations\" this week: any publicly published app can expose its own MCP server, so ChatGPT, Claude, Cursor or any MCP client can use the app directly. The announcement tells you it exists. This guide covers","url":"https://www.reddit.com/r/lovable/comments/1uzh3me/you_can_now_create_your_own_mcp_for_your_lovable/","role":"request","weight":1.2813019,"occurredAt":"2026-07-18T00:31:58.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"lovable","intent":"feature_request","painScore":0.36,"sentiment":0.35714287,"confidence":0.9421337,"matchedPatterns":["missing_feature","manual_process","urgent"],"statement":"The main tool.| | |Free comment on an option: \"I like this one but…\"| | |Open a structured request: type, title, context, reference links, deadline, priority.| | |\"These are my top 3, in this order.\"| |For clients (read)|What it does| |:-|…","title":"You can now create your own MCP for your Lovable app in minutes. Complete guide","body":"  \n  \nLovable shipped \"agent integrations\" this week: any publicly published app can expose its own MCP server, so ChatGPT, Claude, Cursor or any MCP client can use the app directly. The announcement tells you it exists. This guide covers what it actually changes: what \"your app's own MCP\" means, who can consume it (they don't need a Lovable account), how to design good tools, and how far you can take it.\n\n# First, what is MCP?\n\nMCP (Model Context Protocol) is a bridge that lets AI assistants read and act on your app in real time. It's not magic: it's a clear contract of tools you expose so the AI can work with your data, your flow and your users. Think of it as a universal USB-C port for AI: instead of every assistant building a private integration with your app, your app publishes one standardized server and any compatible client plugs in.\n\nThe key property: **the AI never queries your database on its own**. It asks a tool, and the tool does the work: it runs the query, applies your rules, and returns only what you decided to expose. The AI talks to your tools, your tools talk to your data. Designing an MCP is designing that contract of conversation between your app and the AI.\n\n# Two MCPs, two jobs\n\nTalking with builders since the launch, this is the confusion I keep running into: people mixing up **the Lovable MCP** with **their app having its own MCP**. They're different products solving different problems:\n\n* **The Lovable MCP** (lovable.dev/mcp) is for **building**. Your agent talks to the platform: create projects, send prompts, deploy, query the database. One MCP, all of Lovable. Build time.\n* **Your app's MCP** (agent integrations) is for **using** what you built. Each app exposes its own server, and the tools are the app's actual features. One MCP per app. Run time.\n\nThe mental model: the first one is the workshop, the second is the product you shipped, now operable by any assistant.\n\nHere's the cleanest way to keep them straight: **the Lovable MCP is Lovable doing this for its users**: you connect your assistant and drive the platform. **Agent integrations are you doing exactly the same for your users.** Same move, one level down: Lovable made itself consumable from Claude; now your app can be too.\n\nAnd that second one is where the opportunity is: your users can consume specific areas of your app through tools designed *for them*, with permissions and authorizations you control. That's a new value surface: your users use your app not only through the UI, but from Claude or ChatGPT, the interfaces where people are already spending their day, doing their work, and increasingly consuming their data.\n\n# Your app's MCP means letting others consume your app\n\nThat's the strict definition of the feature: third parties (your team, your clients, even other agents) can now use your app through their own AI assistant, without ever opening your dashboard. And \"use\" goes both ways: pulling information out (read) and sending information in (write).\n\nHow that looks in practice:\n\n* **Teams consuming your data, with differentiated access.** If people in your team need data from your app, expose read tools and give each role what it needs: inside a protected integration, each tool can enforce its own role or plan check in your app's backend. Your accountant gets a reporting tool, your PM gets status tools, nobody gets everything.\n* **Teams sending data in.** Say you run an agency and need your team to report how their day ended with each client. Expose a `submit_daily_report` write tool: the assistant interviews them (\"which client? what shipped? any blockers?\"), structures the report, and saves it. No form, no \"I'll log it later\".\n* **Your users chatting with their own data.** Say you built an app where users log their daily cases. With an MCP, those same users can now review and chat with that data from Claude or ChatGPT (\"how many cases did I close this week? which ones are still open?\"), make decisions based on it, and even log new cases from the same conversation. I tested this with the app where my partner and I track our family expenses: we can see and chat with that data, ask how the month is going, and log a new expense without leaving the conversation.\n* **Clients following their projects.** A client asks their own assistant \"what's the status of my project?\" or leaves structured feedback, without ever logging into your dashboard.\n* **A CRM.** Your sales team asks \"what happened with this account?\", logs a call, or schedules a follow-up from the assistant, without opening the CRM.\n* **Other agents.** Not just humans: an automated process can consume your MCP too, like an agent that checks every morning for new activity and writes a digest for your team.\n\nThe principle behind all of these: **the easier you make it for people to consume information and to send information, the better the data you get back**, and the more useful every other tool becomes.\n\nOne boundary worth stating: **this doesn't replace your UI**. The app is still the app. The MCP is an additional access channel you control: another door into the same product, for the people and agents you decide.\n\n# Read tools consume, write tools act\n\nEvery proposed tool comes labeled **\"Read-only\"** or **\"May modify data\"**, and that label is the whole design decision:\n\n* **Read tools** answer questions: `list_items`, `get_status`, `summarize_round`. Low risk, expose these first.\n* **Write tools** change state: `create_request`, `add_item`, `update_status`. Each one is a door into your data. Add them deliberately, one at a time.\n\nOne server can expose both kinds at the same time. That's the normal shape, and it's what makes the agency example above work. Each individual tool stays one or the other: a tool either reads or it writes (and \"writes\" covers create, update and delete).\n\nIf you've heard the term **CRUD**, this is that: Create, Read, Update, Delete, the four basic things any app does with data. Your MCP is choosing which of those four verbs an assistant is allowed to perform, on which data, for whom.\n\n# Governance: who can consume your MCP?\n\nThe short answer: whoever you decide. The people calling your MCP are **your app's users, not Lovable users**. They don't need a Lovable account and they never see Lovable. Here are the possibilities:\n\n* **Your end users.** Clients who live in chat, technical-but-not-designer reviewers, teams that track things by voice or text. They connect their assistant once and use your app from there.\n* **Your internal team.** Designers checking feedback fast, PMs following up from their assistant, or role-specific consumers: your *accountant* connecting once to run \"generate this month's sales report with transaction ids\" against a reporting tool you exposed just for that role.\n* **Other AI agents.** Scheduled processes and backend agents can call the same tools as humans do, and they go through the same access rules, so an agent gets exactly the permissions of the account it connects with.\n\nAnd if your platform is **multi-tenant or has different roles**, you can go further: each person sees some things and not others. A client only sees their own projects, an admin sees everything, a team member sees their assignments. The same rules your app already enforces apply to the MCP. Which leads to the real takeaway of this section: **design your MCP around who is going to use it**. The tools your accountant needs are not the tools your clients need, and pretending one generic set serves everyone is how MCPs end up ignored.\n\n# The identity problem (read this before exposing any write tool)\n\nWhen an assistant calls one of your tools there's no session, no cookie, no logged-in user from your app's point of view. So for any write tool the first question is: **who is acting?**\n\n* **Public + identity as a parameter.** The tool accepts an email as an argument. Fast, and completely unverifiable: anyone on the internet can write data signed as anyone else. For anything where \"who said what\" matters, this quietly destroys the record.\n* **OAuth (sign-in required).** The user connects their assistant once, signs in as their real app user, and from then on the assistant acts *as them*: the user id comes from the token, not from a parameter, and your RLS policies apply exactly as in the app. This is the **default**: if you don't answer the access question when enabling, Lovable uses protected access.\n\n**Prerequisites worth knowing:** OAuth mode needs real Supabase Auth in your app. If your app \"authenticates\" with something lighter (an email allowlist, a localStorage gate), enabling a protected MCP means migrating that login first. On Lovable Cloud the OAuth server comes pre-configured; if you connected your own Supabase, you have to enable the OAuth 2.1 authorization server in your Supabase dashboard and reconnect the project. Also: access is all-or-nothing per integration, you can't mix public and protected tools in one server. Fine-grained rules (role, ownership, plan) live inside each tool's backend logic.\n\n# How a call actually flows, and where to turn it on\n\n    User: \"show me the design options under review\"\n     1. The assistant reads your server's manifest (the public menu of tools)\n     2. It sees list_options and picks it, because the description matches\n     3. Your server runs the tool, queries your data, returns the result\n     4. The assistant answers in natural language\n\n**Where it lives:** editor → \"More\" menu → Agent integrations → Enable (it runs a build, so it uses credits). Lovable reads your app's logic, proposes the tool list, and you can ask it to add, remove, rename or adjust tools. The integration runs on your live published app, not a copy: the MCP link only activates once the app is publicly published, and every publish updates the server with your latest tools. You can also keep asking Lovable to design new tools based on what your app does, who will call them, and what role that caller has.\n\n**The security check is real, and double:** a basic check on every publish (warns if tools don't require authentication), plus a deep scan for public integrations that looks for private-data exposure, unintended record changes, bulk data access and paywall bypass. Findings show up under More → Security.\n\n**How people connect:** your integration gets an MCP link, and users add it as a *custom connector* in their assistant. Lovable shows step-by-step instructions for ChatGPT and Claude under \"How to connect\", and the same link works in Claude Code, Cursor or VS Code. There's no public directory of app MCPs: people can only connect if you share the link with them.\n\n# Designing good tools (the part that separates useful from ignored)\n\n* **Name tools after what people want to do, not after database operations.** `submit_feedback` (\"use this when the user wants to say what to change or keep\") beats `create_feedback_record` (\"creates a record in the feedback table\"). You're designing actions, not plumbing.\n* **The description IS the UX.** The assistant picks a tool by reading its name and description. A vague one gets misused or ignored entirely.\n* **Ask for things a person can say in a sentence.** Which option, keep or change, a comment saved exactly as they said it. If a tool needs a form's worth of fields, let the assistant collect them in conversation.\n* **One tool, one action.** Three small tools (`list_feedback`, `submit_feedback`, `get_request_status`) beat one tool that tries to do everything (`manage_feedback_and_requests`).\n* **Never ask \"who are you?\" as an input.** With sign-in (OAuth), every call already knows who the user is, and your app's own rules decide what that person can see or touch. If a tool takes the user's identity as a parameter, anyone can pretend to be anyone.\n* **Answer tidy.** The assistant has to read the response and explain it. Short, well-labeled data beats a wall of text.\n\n# Use cases, grounded in the tools you'd expose\n\nThere's no fixed catalog here: yo","offTopic":true},{"id":"d2a0150c-70f0-44a2-be06-fbbffe5fcd30","excerpt":"How to Make Claude Code Work Smarter — Having used Claude Code since its API days and now on the Max 2x plan while working on a fairly large-scale project, I've tried various approaches to “consume tokens wisely, even when consuming them.” Since I'll likely continue using this method through this year, I wanted to shar","url":"https://www.reddit.com/r/ClaudeAI/comments/1osbqg8/how_to_make_claude_code_work_smarter/","role":"demand","weight":1.2261268,"occurredAt":"2025-11-09T06:02:46.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"recommendation_request","painScore":0.33562964,"sentiment":-0.074074075,"confidence":0.91801405,"matchedPatterns":["recommend","frustrating","waste_of_time","currently_i_use","manual_process","product:anthropic"],"statement":"This is extremely bothersome and frustrating.","title":"How to Make Claude Code Work Smarter","body":"Having used Claude Code since its API days and now on the Max 2x plan while working on a fairly large-scale project, I've tried various approaches to “consume tokens wisely, even when consuming them.” Since I'll likely continue using this method through this year, I wanted to share it.\n\nI've been developing for over 10 years. While I'm not a developer by profession now and only use it for personal side projects, I've spent about $2000 this year on Anthropic and other LLMs and want to share my results.\n\n# 1. Claude Code Needs Restrictions\n\nClaude Code is excellent in most situations.\n\nHowever, when working on various package modules, backends, frontends, etc., within a massive monorepo, Claude starts to get confused.\n\nMore precisely, in this vast space, it becomes highly confusing about which project is currently active, which project was worked on in the previous session, and the usage for tests or each specific module.\n\nWorking on a single project, separating into microservices, connecting only one Claude Code per project\n\nThese methods might be slightly more efficient and minimize Claude's confusion, but after trying them all, I concluded that Claude itself needs limitations or guidelines.\n\n# 2. Claude Code reads [CLAUDE.md](http://CLAUDE.md)\n\nWhen you first run Claude Code in a project, it outputs a message recommending you create a project-specific instruction file called CLAUDE.md using the /init command.\n\nLike most Claude users, you've probably created a CLAUDE.md file and added various project-specific instructions.\n\nHowever, if you only use Claude Code within a single session—meaning one conversation—and then stop, there's generally no major issue. But if you continue working by connecting to a previous session, due to features like Auto Compact (which Anthropic heavily promotes) for automatic context compression, or due to Claude Code CLI memory issues causing it to restart after closing, Claude Code begins to ignore CLAUDE.md.\n\nThis situation becomes particularly severe after Auto Compact occurs; post-Auto Compact, it won't even reference the content written in CLAUDE.md.\n\nWhile it summarizes the previous session's content and passes it as a prompt to the next session, it literally fails to properly convey the instructions being followed, any limitations set during that session, or any user interventions and subsequent instructions given midway.\n\nTherefore, if Auto Compact occurs immediately after finishing a code task and moves to the next session, Claude in that session will often make the very foolish mistake of “interpreting on its own” based solely on the prompt carried over from the previous session. It will then delete the already completed code, claiming it's incorrect, or start the task over from the beginning.\n\n# 3. Hook functionality depends entirely on how you use it\n\nWhile using Claude Code, I find myself wondering why I only started using the Hook feature now.\n\nGuidelines entered in Markdown can instruct Claude, but whether it follows them is entirely up to Claude.\n\nHowever, Hooks can create “enforceability” for Claude Code.\n\nThey can be used in many ways, but examples include the following:\n\n1. Command restrictions\n2. Token restrictions\n3. Pattern restrictions\n4. Restrictions on incorrect behavior\n5. Instructions on what to prioritize when a session starts\n\nBeyond these, various combinations are possible. When I used them, they were extremely useful and significantly curbed Claude's tendency to run wild.\n\nThe hooks I currently use are listed below.\n\n    auto_compact.py\n    command_restrictor.py\n    context_recovery_helper.py\n    detect_session_finish.py\n    no_mock_code.py\n    pattern_enforcer.py\n    post_session_hook.py\n    post_tool_use_compact_progress.py\n    pre_session_hook.py\n    secret_scanner.py\n    session_start.py\n    timestamp_validator.py\n    token_manager.py\n    validate_git_commit.py\n\nTo explain,\n\n1. Whether starting a new session or entering via Auto Compact from a previous session, session\\_start or pre\\_session\\_hook displays a summary of the previous session.(Details about the summary will be covered below.)\n2. Every command executed by Claude must first pass through command\\_restrictor. This restricts most incorrect command inputs.\n3. It checks the current token usage. If you want to limit the number of tokens used, this part enforces the limit and halts the task.\n4. Once a task is completed or code is modified, scripts like secret\\_scanner and no\\_mock\\_code perform basic security checks and inspect items marked as TODO but not yet implemented. Claude may claim to have implemented something, but many TODO items remain unimplemented. This forces the implementation of those parts.\n5. If Auto Commit is enabled in Hook settings or Claude itself offers to perform a Git commit, commit messages like “by Claude” can end up messy without the developer's knowledge. Therefore, if Claude attempts a git commit, it must pass validate\\_git\\_commit. This ensures clean commit messages by restricting invalid formats or unnecessary phrases like “Co-Auth.”\n\nThe most useful aspects of the current Hook configuration are command restrictions and providing a clear summary of the previous session during Auto Compact.\n\nThe automatic context backup and summary provision for the next session follow a simple flow as described below.\n\nClaude Auto Compact triggers → PreCompactHook executes → Hook script backs up current context file (JSONL file provided by Claude) → Initial refinement of unnecessary parts from the backup (reducing approx. 7-8Mb to 100-200Kb) → Using the refined content, generate a summary via Claude Haiku 4.5 model using Claude Code CLI → Display the summarized content at the start of the next session and notify Claude about what was done in the previous session and what needs to be done next\n\nWriting it out, it's not exactly simple.\n\nThe key point is that by taking the current context source, extracting only the necessary parts, requesting Claude to generate a summary, and then providing that summary at the start of the next session (e.g., via PreSession), we can proceed with longer tasks more reliably. I'm satisfied with this approach.\n\nCommand constraints are also useful for monitoring all commands generated by Claude Code, preventing unauthorized commands, or controlling commands that can't be managed via curl or Claude Code's permission features.\n\nFor example, even if curl is set to Allow in Claude Code Settings, it still asks for permission every single time it's used.\n\nThis is extremely bothersome and frustrating. While I might not have found other methods, most approaches I tried weren't useful for me.\n\nThe command restriction script allows clear differentiation between Allow/Deny/Ask. Even if a specific command is permitted, it can be set to Ask for user confirmation. Commands that require permission every time can be automatically set to Allow.\n\n(For example, even if `rm -rf` is set to Allow, using this script will prompt the user to confirm usage.)\n\n# 4. Skills must be used with Hooks\n\nThe recently released Claude Skills offer various capabilities.\n\nThe traditional Agent approach required the hassle of explicitly invoking the Agent. Skills, however, are like Claude saying, “Hey, I can use this skill!” Properly configured, they prevent scenarios where the [CLAUDE.md](http://CLAUDE.md) file exceeds 3000 lines.\n\nHowever, Skills aren't a panacea.\n\nThese are “guidelines” for using the feature properly, but whether Claude actually follows them is up to Claude.\n\nTherefore, even if you create and possess various technologies like backend, frontend, API, etc., using Skills, they're useless if you can't properly control them.\n\n# 5. Set up a project-specific CLI whenever possible\n\nMost of my projects are Python-based, and lately, I've been working a lot with FastAPI + React.\n\nSpeaking specifically for Python/FastAPI, I recommend using the Typer/Rich library to build a CLI that can be used within your project.\n\nDuring development, you have to handle many tasks.\n\nYou need to manage databases, manage API specifications, and when testing, you often have to manually create test accounts, apply permissions, check the currently running backend or frontend, and perform various other manual tasks.\n\nFirst, use Claude Code to build a CLI that can handle these manual tasks.\n\nEspecially when you need to directly access and modify the database or execute queries, Claude will almost always attempt to use the database's CLI for access. It will repeatedly ask for the login credentials, and even if provided, it often fails to perform the task correctly.\n\nBy creating a dedicated CLI for these tasks and teaching Claude how to use it, you save significant time. Claude won't waste time trying various approaches haphazardly; it will simply use the CLI to perform the necessary operations.\n\nOf course, this CLI is not for production use. A separate production-ready CLI must be configured; this setup is purely for development purposes.\n\n# 6. Auxiliary Storage is Essential\n\nClaude is not omnipotent.\n\nAt the start of each new session, it will ask like a new employee: what happened in the session, when this code was modified, and how modifications were attempted.\n\nTo mitigate this as much as possible, there are many auxiliary memory solutions available for Claude, including open-source memory and subscription-based memory.\n\nI use ChromaDB. I've tried other expensive, supposedly good options like Qdrant, Mem0, and Pinecore before, but I still find ChromaDB sufficient.\n\nHowever, I wanted identical memory across work, home, and mobile. While I could have used Chroma Cloud, I preferred to keep sensitive parts under my own management. So I started a separate project and recently began deploying it.\n\nOf course, even if you connect ChromaDB, there's no guarantee Claude will use it, so you need to enforce it.\n\nThis applies to other memory solutions as well.\n\n# 7. Sentry occasionally helps\n\nClaude only checks logs when explicitly told to “look at them.”\n\nBut even then, it consistently treats the log folder differently per session. If the logs aren't where that session's Claude expects them, it deems “no logs exist” and starts making assumptions and modifications on its own.\n\nOf course, if you tell it the log folder and ask it to check the last log, it finds the issue over 90% of the time.\n\nHowever, based on my continued use, log files inevitably keep growing, leading to significant waste of unnecessary tokens.\n\nThis is where Sentry proves useful.\n\nSentry holds the full backtrace for the error, enabling analysis of only the necessary parts.\n\nHowever, even if you tell Claude to use Sentry, it won't enforce it. If there are multiple projects, Claude won't even bother looking for the project and will just spit out “Cannot find” and proceed with guesswork.\n\n# 8. Claude's Think Function Is Unpredictable\n\nClaude Code has a standard mode and a Think mode.\n\nThink mode acts as an intermediate guide, allowing Claude to think for itself, judge which direction is best, and proceed accordingly.\n\nHowever, this feature isn't perfect either.\n\nSometimes it gets too absorbed in its own thoughts or throws around wild, speculative theories, producing nonsensical results.\n\nFor users who have to spend extra tokens to use the Think feature, it's enough to make your head spin.\n\nTherefore, unless you're a heavy user like Max Plan, I recommend working mostly in Normal mode and only using Think for highly complex tasks requiring deep project-wide understanding.\n\n# Conclusion\n\nI hope this content offers some assistance to those coding using Claude or other AI LLMs.\n\nThe Claude Hook, Skills, CLI, and Memory samples mentioned in the article are available below. Since they're based on my project, you may need to make some adjustments for your own projects.\n\nI'm currently developing and refining Hooks, so this repository will likely continue to be updated.\n\nI've wanted to release this for a while, but various ","offTopic":true},{"id":"d392ebee-97cd-4066-aafb-2c550b9c8e6e","excerpt":"A long-time user trying the Evernote + Claude MCP connection - my brain + Evernote/GTD/second brain + Claude + more connections - it is game changing! — ***TL;DR:*** *16-year Evernote user (\\~16,000 notes, full GTD system) here. The Claude MCP connection is the missing piece I’d always wanted. It sits on top and joins ","url":"https://www.reddit.com/r/gtd/comments/1ugzzuo/a_longtime_user_trying_the_evernote_claude_mcp/","role":"pain","weight":1.1891567,"occurredAt":"2026-06-27T11:10:14.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"gtd","intent":"feature_request","painScore":0.49333334,"sentiment":-0.33333334,"confidence":0.79631025,"matchedPatterns":["missing_feature","urgent"],"statement":"The Claude MCP connection is the missing piece I’d always wanted.","title":"A long-time user trying the Evernote + Claude MCP connection - my brain + Evernote/GTD/second brain + Claude + more connections - it is game changing!","body":"***TL;DR:*** *16-year Evernote user (\\~16,000 notes, full GTD system) here. The Claude MCP connection is the missing piece I’d always wanted. It sits on top and joins your notes up with email, calendar, files, and the wider web. Critically: it doesn’t replace me in GTD. GTD absolutely only works when you’re personally in it — but this takes what I can do with it to a whole new level, and improves the efficiency and maintenance — freeing me up to focus on clarifying and organising, doing, and helping me reflect and be more creative and productive. Use cases I’ve been running: assisting inbox management, literature triage, grant-idea matching, GTD reviews and inbox triage, project status reports, knowledge maps and dashboards, trip and meal planning, and questions that cut across life areas. One that’s genuinely changed things: I can write a task note in Evernote and have Claude pick it up via Cowork, act on it directly, e.g., filing emails, updating spreadsheets, drafting documents, updating a blog - and then report back and move the task to completed. Still early days, but there’s far more here than the first wave of articles covers.*\n\n**Claude helped me draft this note (sorry, I've spent hours working with the Claude and Evernote, and am so excited that I want to share asap, but my brain is now too tired to write it all on its own) and the mermaid diagram.** **It then even created the note in my Evernote, here:** [**Reddit post — Evernote Claude MCP: what's possible (r/Evernote draft)**](https://share.evernote.com/note/cdf1f1ee-bc6d-0760-dc10-3714b75ade73)The auto mod keeps removing the full content when I try to paste it here :( sorry, so please read the full content in my Evernote note\n\nI've used Evernote as my main second brain for about 16 years. It has grown into a bit of a beast, somewhere around 16,000 notes, with an all of life robust GTD system within it, holding most of my life: work, research, projects, reference material, personal odds and ends, lists, all of it. For years the thing I always wished for was something that could think across the whole lot. The new Claude MCP connection is the closest I've come to that, and I wanted to share some of what it's been like, because the articles I've seen so far only cover a small slice of what's possible.\n\nHere's some of what I've been doing with it so far, and the growing list of ideas I’m noting down:\n\n* Find all notes with a specific tag and rank them against a grant call or project — reads them, clusters by theme, flags what’s ready, what overlaps, what’s new\n* Triage a notebook full of saved article emails, extract the papers and prep them for a reference manager\n* Pull scattered notes on a topic into one coherent summary\n* Draft a paper or grant section from rough idea-notes that were never properly joined up\n* With Cowork: draft a full grant application in the required format, pulling from your notes and the grant guidelines, and create or update supporting documents and spreadsheets\n* Turn a messy brain-dump note into a proper draft\n* Take a backed-up inbox and pull out the urgent and important next actions, weighted by what’s actually live right now, using email and calendar too\n* Scan all projects and surface the stale ones with no real next action, then suggest or rewrite better ones\n* Run a weekly review — go through the inbox, flag unprocessed notes, list projects that have gone quiet\n* Pick out which open tasks Claude could just do, and which ones to drop entirely\n* Grab one feasible thing from the someday/maybe pile when there’s a spare half hour\n* Write a task note and have Claude pick it up via Cowork and act on it directly: file an email, update a budget spreadsheet, add something to a document, post to a blog — then report back and move the note from next actions to completed\n* Generate a map of all 16,000+ notes — themes, clusters, connections — and actually reason about why things link, not just draw lines\n* Build on-the-fly custom maps and dashboards around whatever you’re working on, no plugins, no setup\n* Create interactive clickable reports from your notes — like the Obsidian graph view but tailored and much more powerful\n* Track how themes and thinking have shifted across years of notes\n* “What do I already know about this?” before a meeting, pulling together everything saved on a person, topic or place\n* Meal planning from saved recipes, shopping list sent to a tasks app\n* Trip planning from years of saved travel clippings\n* Book, film or restaurant picks from your own lists, matched to the mood\n* Find a note from years ago you can’t remember the keywords for, just by describing what it was about\n* Pre-meeting briefs built from past meeting notes\n* Boil a whole project’s note trail down to a short status update\n* Pull every action item buried across dozens of notes into one list\n* Draft a handover or onboarding doc from accumulated project notes\n* Answer questions that span different parts of your life — values, career, a project — and bring them together\n* “How has my thinking on this changed over the years?” across a decade and a half of notes\n* Audit your own system — find what’s drifted, what’s undocumented, orphaned tags, duplicates, notes in the wrong place","offTopic":false},{"id":"8dd89c70-0b03-4ff1-9795-37985215385f","excerpt":"My complete Claude Code workflow: 0 to deployed in under a week — **Warning**: Long post ahead\n\nMany of you asked me to share this, so here's the exact workflow I use when building apps and websites with Claude Code. This works with any AI agent.\n\nFirst, I figure out exactly what I want to build. I do my own brainstorm","url":"https://www.reddit.com/r/ClaudeCode/comments/1ntdog6/my_complete_claude_code_workflow_0_to_deployed_in/","role":"request","weight":1.17267,"occurredAt":"2025-09-29T09:41:10.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeCode","intent":"feature_request","painScore":0.22228152,"sentiment":0,"confidence":0.9594107,"matchedPatterns":["please_add","manual_process","praise"],"statement":"I use Google dorking with this filter: site:reddit.com \"tech name\" \"feature request\".","title":"My complete Claude Code workflow: 0 to deployed in under a week","body":"**Warning**: Long post ahead\n\nMany of you asked me to share this, so here's the exact workflow I use when building apps and websites with Claude Code. This works with any AI agent.\n\nFirst, I figure out exactly what I want to build. I do my own brainstorming, then spend serious time researching people and companies who already built something similar. I do this for two reasons: to discover new ideas or angles I missed in my initial analysis, and to find complaints about existing products so I can fix them. I use Google dorking with this filter: site:reddit.com \"tech name\" \"feature request\". This helps me extract specific information from specific sites.\n\nNext, I choose my tech stack. This part is personal and flexible. I use Next.js, Tailwind CSS, Redis, and Supabase as my four main technologies for full-stack web apps. Pick whatever works for your needs.\n\nNow comes the planning phase. This is where you need to spend the MOST time in the entire development process. I cannot stress this enough. If you plan everything properly, the AI will build it without problems. If you rush this phase, you'll waste massive amounts of time in back-and-forth conversations fixing unforeseen issues, trying to add new features that break the current structure, and constantly reorganizing things that should have been planned from the start. Spend days on planning if needed. It's worth it. I ALWAYS use Claude 4.1 Opus planning mode for this. I start by creating an executive plan, which is a short, concise document explaining the features I want at a high level. Think of it like pitching to a company director. I iterate this plan manually until every piece of the puzzle fits perfectly. Don't rush this. A solid plan means smooth development. A rushed plan means chaos.\n\nBased on the executive plan, I generate a more detailed technical plan that explains each feature in greater depth (but not excessively). I usually ask Claude Code to do this since it's an automated process. Once it finishes, I review manually to make sure it didn't go off track and everything matches my vision exactly.\n\nThen I run several iterations with Claude Code on the technical plan to make sure features are correctly ordered. This prevents having to backtrack later. No point setting up database fetching code before the database exists, right? Getting the order right saves massive amounts of time.\n\nOnce everything is properly ordered, I generate extremely explicit and well-explained .md files for each feature. These files need to be so clear that an AI agent can read and build them without getting lost. Think of them as instruction manuals that leave zero room for misinterpretation.\n\nAfter planning is done, I generate empty folders in my project and set up the structure. This structure follows the standard practices of whatever tech stack I'm using. A Next.js project structure looks completely different from a Python project structure, and that's fine. Each stack has its own conventions. But here's the non-negotiable part: keep things organized. Always. A messy structure now means a nightmare later when your project grows. I also create [CLAUDE.md](http://CLAUDE.md) files for each subdirectory, telling Claude Code how to behave with those files and what not to do. These act as guardrails to prevent the AI from making structural mistakes.\n\nI create a general-purpose [CLAUDE.md](http://CLAUDE.md) file in the project root. This file is concise, direct, and highly personalized to my needs. If I'm building a web app, I always tell Claude Code to NEVER execute \"npm run dev\" or \"npm run build\" without my permission. When I mention Supabase, I tell it to always fetch data using the MCP or by calling the specialized Supabase agent. There are many other instructions of this caliber in there.\n\nDepending on my needs, I create several pre-post tool use hooks to force Claude Code to execute certain actions before and after each modification. Keep in mind: these actions will run before and after EVERY single tool call Claude Code makes. This includes compiling .tsx, .py, or .cpp files to make sure it didn't make syntax errors. This really depends on what you need, but be aware of what you're setting up. If you add heavy actions here, they'll run constantly throughout your entire development session.\n\nOnce I have the planning done, I ask Claude Code to generate several context files explaining what my project is about. Along with the phase planning files, I attach these to another LLM (Claude Desktop in my case). Using very specific instructions designed to generate better prompts, I ask it to create all the prompts needed to build the feature I'm interested in. Here's what you MUST tell the LLM when generating these prompts: they need to be created in a way that produces NO gaps in the actual building phase. Every prompt must be logically ordered so one builds on top of the previous one. I also always tell it to skip any optimization or deployment phases entirely. Why? Because the prompts should already be written with production-level code in mind from the start. No point building something twice. Build it right the first time, ready for production.\n\nBefore moving to the building phase, I generate several custom agents for each independent section of the project that might be useful. If I'm creating a full-stack website, I'd generate agents for TypeScript, Supabase, Backend, API, Performance, and directory-expert, each with their own guidelines. Then I generate an AGENTS.md file (the equivalent of CLAUDE.md but for agents) that forces them to NEVER execute actions. They only provide context in their area of expertise to the main orchestrator (Claude Code in this case). Why do I force this restriction? Because I need to see in real-time in the CLI what changes Claude Code is applying and verify it's doing what I told it to do. When agents execute actions directly, their output and the changes they make are NOT visible in the terminal. This means you lose visibility and control. By forcing agents to only provide context, every single code change goes through the main orchestrator, and I can see everything happening in my terminal.\n\nDuring the building of any feature with Claude Code, I generally use several custom commands I've created depending on each part of the process. If I'm building something new, I first ask Claude Code to analyze the context related to that thing. Then using MY custom /implement command (which tells Claude Code to build something based on the context in the chat), I ask it to build what I need. Here's the thing: I always use Sonnet 4 model, and very rarely Opus 4.1 unless it's something really complex.\n\nI build my apps by phases and features. This ensures everything works perfectly before moving to the next point. This is non-negotiable in my opinion. Otherwise the codebase grows at an astonishing speed and bugs inevitably appear. These bugs become harder to identify and fix over time, so I solve them as I build things.\n\nMany times, the 200k token context that Claude Code has before compressing the chat is NOT enough (for me) to do everything I want in one go. When this happens, I do one of two things: clean the context, load the context files (the planning files generated earlier) and continue, or ask Claude Code to generate a .md file explaining everything done during the coding session and load it in a new chat. Another option is pressing \"esc\" and going back to previous messages, which from what I've seen (haven't tested it myself) reduces the context window limit while maintaining context.\n\nAfter building a feature, I usually run CodeRabbit from the CLI to identify security flaws I might have overlooked. Claude Code often skips this aspect of programming, so I fix these issues manually. You can automate this with post-tool use hooks or custom [CLAUDE.md](http://CLAUDE.md) rules. I prefer hooks for tasks like this because they run automatically after each modification, catching security issues immediately rather than letting them pile up.\n\nIf I find bugs during development, I have custom commands to systematically debug my codebase. A really useful tip for solving bugs when vibe coding is to ask Claude Code to insert console.logs() or print() statements at key points in the program. Then feed it the console output until it can identify and fix the bug.\n\nAfter building several features, I take time to review the code and clean up garbage that Claude Code might have left behind. I usually have a custom command that does this for me: it goes through classes, files, and more looking for unused functions, classes, files, and returns them in report format for me to review manually. If I approve, I tell Claude Code to proceed with deletion. I do this to keep code clean and force Claude Code to reuse existing code. Many times it will generate new files and functions for things already done instead of reusing what exists.\n\nWhen I want to refactor, I usually do it this way (though this depends on the scale of the refactoring). I ask Claude Code to analyze how the system or feature I want to refactor works in depth and generate a very explanatory .md file as context. Based on that, I generate the refactoring plan and make a backup of all files that will be affected. Then I generate the optimized and specific prompts with an external LLM. When generating these prompts, it's really important to tell the LLM to always base itself on the working patterns of the backup files. The code works perfectly there, but needs refactoring to achieve certain goals. Using very specific custom Claude Code commands, I generate a refactoring plan (usually in .json format) that forces Claude Code to follow and update after each modification. This ensures everything happens in an ordered and measured way. Otherwise it starts hallucinating and producing the same errors in loops.\n\nThat's pretty much everything I got to share. As a real showcase, this exact workflow built [vibecodingtools.tech](http://vibecodingtools.tech) in less than 1 week, starting completely from absolute scratch. ","offTopic":true},{"id":"505259aa-db99-4448-8593-1ea30a3dae8f","excerpt":"Most people use Claude Code like a chatbot. Here's what happens when you treat CLAUDE.md as an operating system. — I've been using Claude Code daily everyday — not just for coding, but as a persistent system that remembers context across sessions, follows complex workflows, and manages a knowledge base autonomously. He","url":"https://www.reddit.com/r/ClaudeAI/comments/1qvmjic/most_people_use_claude_code_like_a_chatbot_heres/","role":"pain","weight":1.1124667,"occurredAt":"2026-02-04T11:53:04.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"problem_report","painScore":0.48,"sentiment":0.11111111,"confidence":0.75166667,"matchedPatterns":["frustrating"],"statement":"Every time.**\\*\\* This was the most frustrating lesson.","title":"Most people use Claude Code like a chatbot. Here's what happens when you treat CLAUDE.md as an operating system.","body":"I've been using Claude Code daily everyday — not just for coding, but as a persistent system that remembers context across sessions, follows complex workflows, and manages a knowledge base autonomously. Here's what I've learned that the docs won't tell you.\n\n\n\n\\*\\***1.** [**CLAUDE.md**](http://CLAUDE.md) **is not a prompt. It's an operating system.**\\*\\*\n\n\n\nMost people write things like \"You are a helpful coding assistant. Keep responses concise.\" That does almost nothing.\n\n\n\nWhat actually works is treating [CLAUDE.md](http://CLAUDE.md) as behavioral rules with triggers:\n\n\n\n\\- Don't say \"be helpful.\" Say \"when you encounter X, do Y.\"\n\n\\- Don't say \"remember important things.\" Say \"before every response, check: is there anything in what the user just said that needs to be written to a file? If yes, write it before responding.\"\n\n\\- Don't describe personality. Describe decision trees.\n\n\n\nThe difference is huge. A vague description gives Claude room to interpret. A trigger-action rule gives it no room to skip.\n\n\n\n\\*\\***2. Claude will say \"I'll remember this\" and then forget. Every time.**\\*\\*\n\n\n\nThis was the most frustrating lesson. Claude will say \"I've noted that\" or \"I'll keep that in mind\" — and then next session, it's gone. Because there is no persistent memory unless you build it.\n\n\n\nWhat I did:\n\n\n\n\\- Created a mandatory write-before-speak rule: if something important comes up in conversation, Claude must write it to a file BEFORE continuing the conversation. Not after. Not \"later.\" Now.\n\n\\- Added a self-check: before saying \"I'll remember,\" ask yourself — \"if I don't write this down right now, will the next session know this?\" If no, write it immediately.\n\n\\- Set up hooks that block Claude's response if it says \"I'll remember\" without actually performing a write action.\n\n\n\nThe result: Claude now maintains files across sessions — journals, knowledge bases, tracking documents. Not because it \"remembers,\" but because it writes things down in real time.\n\n\n\n\\*\\***3. Why hooks are the most important layer (and most people don't use them)**\\*\\*\n\n\n\nHere's the thing nobody tells you: [CLAUDE.md](http://CLAUDE.md) rules are suggestions. Claude reads them, \"understands\" them, and then... gradually drifts. It'll follow your rules perfectly for 20 minutes, then start finding \"reasonable\" reasons to skip steps. It's not malicious — it's just how LLMs work. They optimize for the immediate response, not for long-term rule compliance.\n\n\n\nThis is why hooks exist, and why they change everything.\n\n\n\n\\*\\***The enforcement hierarchy:**\\*\\*\n\n\n\n| Layer | What it does | Can Claude ignore it? |\n\n|-------|-------------|----------------------|\n\n| [CLAUDE.md](http://CLAUDE.md) | Rules always in context | Yes — it reads them but can choose to \"interpret\" loosely |\n\n| Skills | Specialized workflows loaded on trigger | Yes — Claude decides whether to invoke them |\n\n| Hooks | External shell scripts that run on events | \\*\\***No**\\*\\* — they execute outside Claude's decision loop |\n\n\n\nHooks are the only layer where enforcement doesn't depend on Claude's compliance. They're shell scripts that fire on specific events (session start, session stop, before/after tool calls). Claude doesn't get to choose.\n\n\n\n\\*\\***Real example — my \"promise checker\" hook:**\\*\\*\n\n\n\nI had a recurring problem: Claude would say \"I'll remember that\" or \"I've noted this\" and then do nothing. It was performing compliance without actual compliance. So I wrote a Stop hook — a bash script that runs every time Claude finishes a response:\n\n\n\n1. It scans Claude's last response for promise words (\"I'll remember\", \"I'll write that down\", \"noted\", etc. — about 30 patterns)\n\n2. It checks whether Claude actually called the Edit or Write tool in that same response\n\n3. If it finds promises without write actions → \\*\\***blocks the response entirely**\\*\\*\n\n4. Claude gets a message: \"You said you'd remember something but didn't write it down. Go back and do it.\"\n\n\n\nClaude literally cannot say \"I'll remember\" and move on. The shell script catches it every time. This single hook eliminated probably 80% of the \"forgot to write\" failures.\n\n\n\n\\*\\***Another example — my startup hook:**\\*\\*\n\n\n\nEvery new session triggers a shell script that:\n\n\\- Loads the full rules file into context\n\n\\- Reads the latest journal entry (so Claude knows recent history)\n\n\\- Runs signal detection: scans directories for unprocessed files, checks if important trackers are stale, flags overdue items\n\n\\- Presents self-check questions Claude must answer before proceeding\n\n\n\nThis means every session starts correctly, regardless of what Claude \"feels like\" doing. It can't skip the initialization.\n\n\n\n\\*\\***The mental model:**\\*\\* CLAUDE.md is the constitution. Skills are the standard operating procedures. Hooks are the police. You need all three, but if you can only build one thing beyond CLAUDE.md, build hooks.\n\n\n\n\\*\\***4. Skills + MCP: how to build workflows that always get triggered**\\*\\*\n\n\n\nSkills have the same problem as [CLAUDE.md](http://CLAUDE.md) rules — Claude has to decide to use them. And it won't always decide correctly (remember the 56% tool-skip rate from Vercel's research).\n\n\n\nThree strategies that actually work:\n\n\n\n\\*\\***Strategy 1: Routing table in CLAUDE.md**\\*\\*\n\n\n\nPut an explicit mapping in your CLAUDE.md:\n\n\n\n\\`\\`\\`\n\n| Trigger | Skill |\n\n|---------|-------|\n\n| Any code change | safe-dev-workflow |\n\n| Bug report | systematic-debugging |\n\n| Content processing | deep-processing |\n\n\\`\\`\\`\n\n\n\nSince [CLAUDE.md](http://CLAUDE.md) is always in context, Claude always sees this table. It's not perfect — it can still \"forget\" — but it's much better than hoping Claude will figure out which skill to use on its own.\n\n\n\n\\*\\***Strategy 2: MCP servers for structured workflows**\\*\\*\n\n\n\nThis is the powerful one. I use an MCP server that provides a 13-step development workflow. When starting any dev task, Claude calls \\`start\\_dev\\_session()\\` which returns:\n\n\n\n\\- A numbered checklist of all 13 steps\n\n\\- Known pitfalls for this project\n\n\\- Friction points from past sessions\n\n\n\nEach step in the checklist explicitly names which skill to invoke. So Claude isn't deciding \"should I use the debugging skill?\" — the workflow tells it \"Step 7: invoke systematic-debugging.\"\n\n\n\nThe MCP approach works because:\n\n\\- The workflow is external to Claude (stored in a server, not in Claude's context)\n\n\\- Each step references the next step, creating a chain\n\n\\- Claude can call \\`get\\_workflow\\_detail(step)\\` for detailed instructions at each point\n\n\\- It's structured data, not prose — harder for Claude to \"reinterpret\"\n\n\n\n\\*\\***Strategy 3: Hook-enforced skill invocation**\\*\\*\n\n\n\nFor critical skills that must ALWAYS fire, you can use a SessionStart hook to force them. My startup hook doesn't just load context — it runs signal detection that determines what needs to happen in this session. If there are unread files, the hook flags them, and Claude knows it needs to invoke the content-processing skill before doing anything else.\n\n\n\n\\*\\***The full architecture in practice:**\\*\\*\n\n\n\n\\`\\`\\`\n\nSession starts\n\n  → Hook fires: [startup.sh](http://startup.sh) loads rules, reads journal, runs signal detection\n\n→ [CLAUDE.md](http://CLAUDE.md) routing table: maps the current task to a skill\n\n→ Skill invokes MCP: start\\_dev\\_session() returns 13-step workflow\n\n→ Each step names the next skill to use\n\n→ Stop hook fires: checks promises were kept\n\n\\`\\`\\`\n\n\n\nEvery layer reinforces the next. Hooks guarantee the boundaries. [CLAUDE.md](http://CLAUDE.md) handles routing. MCP provides structure. Skills provide depth.\n\n\n\n\\*\\***4. The \"passive context beats active tools\" insight**\\*\\*\n\n\n\nThis was counterintuitive. You'd think giving Claude more tools (web search, file search, etc.) makes it smarter. But Vercel's team found that putting knowledge directly into [CLAUDE.md](http://CLAUDE.md) (passive context that's always there) outperformed giving Claude tools to look things up (active retrieval that Claude has to decide to use).\n\n\n\nWhy? Because current LLMs are unreliable at deciding WHEN to use a tool. They'll skip it 56% of the time. But if the knowledge is just... there, in the context, Claude uses it 100% of the time.\n\n\n\nPractical application: don't make Claude \"search for your project structure.\" Put your project structure in CLAUDE.md. Don't make Claude \"look up your coding standards.\" Put your coding standards in CLAUDE.md. Save the tools for things that genuinely need real-time lookup.\n\n\n\n\\*\\***5. What this actually looks like in practice**\\*\\*\n\n\n\nMy Claude Code setup:\n\n\\- Maintains a persistent knowledge base across sessions (writes observations, tracks changes, keeps journals)\n\n\\- Has a \"wake-up\" file — every session starts by reading what the previous session left behind. It's like a shift handoff between versions of itself\n\n\\- Autonomously scans for new content in specific directories and processes it\n\n\\- Follows a 13-step workflow for development tasks with checkpoints\n\n\\- Has custom skills for different task types (content processing, debugging, knowledge management)\n\n\\- Uses MCP servers for external knowledge access\n\n\n\nThis isn't a toy. It's my daily working system. I use it for project management, content processing, technical development, and knowledge organization.\n\n\n\n\\*\\***6. The meta-lesson**\\*\\*\n\n\n\nClaude Code is not a chatbot and it's not an IDE plugin. It's a programmable agent. The bottleneck isn't Claude's intelligence — it's your ability to specify what you want in precise, trigger-action rules rather than vague descriptions.\n\n\n\nIf you're writing \"be concise and helpful\" in your [CLAUDE.md](http://CLAUDE.md), you're using maybe 5% of what this tool can do.\n\n\n\n\\---\n\n\n\nHappy to answer questions about any of these. I can share specific examples of [CLAUDE.md](http://CLAUDE.md) rules that work vs. ones that don't.","offTopic":true},{"id":"9ac9a26b-ea3e-4a32-b6a2-c2005cee71cd","excerpt":"Use Gemini CLI within Claude Code and save weekly credits — I developed and open sourced [Zen MCP](https://github.com/BeehiveInnovations/zen-mcp-server/) a little while ago primarily to supercharge our collective workflows; it's now helped thousands of developers (and non-developers) over the past few months. Originall","url":"https://www.reddit.com/r/ClaudeAI/comments/1nyizsj/use_gemini_cli_within_claude_code_and_save_weekly/","role":"pain","weight":1.1007917,"occurredAt":"2025-10-05T08:41:56.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"problem_report","painScore":0.45,"sentiment":0.7714286,"confidence":0.75916666,"matchedPatterns":["doesnt_work"],"statement":"You can now use an existing Codex subscription and invoke code reviews from within ClaudeCode: **Second Update**: New tool added - ensures you always get current, accurate API/SDK documentation by forcing the AI to search for the latest in…","title":"Use Gemini CLI within Claude Code and save weekly credits","body":"I developed and open sourced [Zen MCP](https://github.com/BeehiveInnovations/zen-mcp-server/) a little while ago primarily to supercharge our collective workflows; it's now helped thousands of developers (and non-developers) over the past few months. Originally, the idea was to connect Claude Code with other AI models to boost productivity and bring in a broader range of ideas (via an API key for Gemini / OpenRouter / Grok etc). Claude Sonnet could generate the code, and Gemini 2.5 Pro could review it afterward. Zen offers multiple _workflows_ and supports memory / conversation continuity between tools.\n\nThese workflows are still incredibly powerful but with recent reductions to weekly quota limits within Claude Code, every token matters. I'm on the 20x Max Plan and saw a warning yesterday that I've consumed ~80% of my weekly quota by seemingly [doing nothing](https://github.com/anthropics/claude-code/issues/8918). With Codex now becoming my primary driver, it's clearer than ever that there's tremendous value in bringing other CLIs into the workflow. Offloading certain tasks like code review, planning, or research to tools like Gemini lets me preserve my context (and weekly limits) while also taking advantage the other CLI's stronger capabilities.\n\nGemini CLI (although woefully bad on its own for agentic tasks; Gemini 2.5 Pro however is absolutely amazing in reasoning) offers up to **1000 free requests** a day! Why not use the CLI directly for simpler things? Documentation? Code reviews? Bug hunting? Maybe even simple features / enhancements?\n\nZen MCP just landed an incredible update today to allow just that - you can now use Gemini CLI **directly from within Claude Code** (or Codex, or any tool that supports MCP) and maintain a single shared context. You can also assign multiple custom _roles_ to the CLI (via a configurable system prompt). Incredibly powerful stuff. Not only does this help you **dramatically cut down on Claude Code token usage**, it also lets you **tap into free credits from Gemini!**\n\nI'll soon be adding support for Codex / Qwen etc and even Claude Code. This means you’ll be able to **delegate tasks across CLIs** (and give them unique roles!) in addition to incorporating any other AI model you want: e.g. use the `planner` tool with GPT-5 to plan out something, get Gemini 2.5 Pro to nitpick and ask Sonnet 4.5 to implement. Then get Gemini CLI to code review and write units tests - all while staying in the same shared context and saving tokens, getting the best of everything! Sky's the limit!\n\n**Update**: \nAlso added support for Codex CLI. You can now use an existing Codex subscription and invoke code reviews from within ClaudeCode:\n\n```\nclink with codex cli and perform a full code review using the codereview role\n```\n\n**Second Update**:\nNew tool added [`apilookup`](https://github.com/BeehiveInnovations/zen-mcp-server/blob/main/docs/tools/apilookup.md) - ensures you always get current, accurate API/SDK documentation by forcing the AI to search for the latest information systematically (simply saying `use latest APIs` doesn't work - it'll still use APIs it's aware of at the time of its training cut-off date).\n\n```\nuse apilookup how do I add glass look to a button in swift?\n```\n\n--\n\nThe video above was taken in a single take (trimmed frames to cut out wait times):\n\n1. I cloned `https://github.com/LeonMarqs/Flappy-bird-python.git` (which does not contain the scoring feature)\n2. Asked Claude Code to use the `consensus` Zen MCP tool to ask GPT-5 and Codex what they think would be nice to add quickly\n3. Asked Claude Code to get Gemini CLI to perform the actual implementation (Gemini CLI received the full conversation + consensus + request + the prompt)\n4. Tested if it works - and it does!","offTopic":true},{"id":"bd139952-c91f-44a4-bdac-9add6bf12984","excerpt":"20 Claude connectors that completely change how you manage projects, write emails, and close deals — TLDR: You do not need to juggle dozens of AI tools when Claude can theoretically run your entire business. By enabling these 20 Claude Connectors, you can remove all friction between your apps and let Claude act across ","url":"https://www.reddit.com/r/ThinkingDeeplyAI/comments/1su619u/20_claude_connectors_that_completely_change_how/","role":"pricing","weight":1.0848441,"occurredAt":"2026-04-24T04:58:09.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ThinkingDeeplyAI","intent":"pricing_complaint","painScore":0.3,"sentiment":0.6666667,"confidence":0.8344955,"matchedPatterns":["free_tier","manual_process"],"statement":"Google Drive Instead of manually downloading and uploading files, Claude can search and read your Google Docs, Sheets, and Slides mid-chat.","title":"20 Claude connectors that completely change how you manage projects, write emails, and close deals","body":"TLDR: You do not need to juggle dozens of AI tools when Claude can theoretically run your entire business. By enabling these 20 Claude Connectors, you can remove all friction between your apps and let Claude act across your Google Workspace, CRM, design tools, and project managers directly from one chat interface.\n\n**Stop Switching Apps and Let Claude Run Your Workflows**\n\nThere is nothing inherently wrong with using multiple dedicated AI tools for different tasks. You can learn a wide range of skills and build highly specialized workflows. However, if you want the leanest, most efficient, and most centralized operating system for your daily work, using Claude as your primary hub is by far your best option.\n\nThe true power of Claude unlocks when you connect it directly to the tools you already use. Claude Connectors remove the friction of constantly moving between different tabs, copying context, and pasting outputs. You simply connect your tools once, and Claude can search, read, draft, and execute actions across them directly from a single conversation.\n\nHere is a comprehensive guide to every Claude Connector worth enabling right now, organized by how they can transform your daily operations.\n\n**Document and Knowledge Management**\n\n1. Google Drive  \nInstead of manually downloading and uploading files, Claude can search and read your Google Docs, Sheets, and Slides mid-chat. You can ask it to synthesize information across multiple strategy documents or extract specific data points from a spreadsheet without ever leaving the conversation.\n\n2. Notion  \nClaude connects directly to your Notion workspace. It can search your pages, pull project briefs, and reference your internal wikis mid-chat. This turns Claude into an instantly accessible knowledge base assistant that always has the right context.\n\n3. Microsoft 365  \nFor enterprise users, this connector allows Claude to access SharePoint, OneDrive, Outlook, and Teams context. You can synthesize information across your entire Microsoft ecosystem in one seamless interaction.\n\n**Communication and Scheduling**\n\n4. Gmail  \nClaude can search your inbox, surface key email threads, and draft contextual replies on command. This is incredibly powerful for catching up after a vacation or drafting nuanced responses to complex client inquiries.\n\n5. Slack  \nBy connecting Slack, Claude can send messages, fetch channel history, and pull any thread into your conversation instantly. You can ask Claude to summarize a chaotic project channel and then draft an update to send back to the team.\n\n6. Google Calendar  \nClaude can schedule meetings, manage calendar invites, and handle RSVPs based on your actual availability. It acts as a true executive assistant, negotiating times and setting up the events directly.\n\n**Sales and CRM**\n\n7. HubSpot  \nClaude can read your CRM data to summarize active deals, draft follow-up emails, and surface pipeline insights. You can ask it for a briefing on a specific client before a call, and it will pull the latest interactions from HubSpot.\n\n8.  [Apollo.io](http://Apollo.io)  \nThis connector allows Claude to find buyers, research prospects, and book meetings directly from the chat. It streamlines the outbound sales process by bringing the database into your conversational interface.\n\n9. Clay  \nClaude can research target accounts, find key prospects, and personalize outreach at scale through Clay. This integration is essential for highly targeted, data-driven outbound campaigns.\n\n10. Intercom  \nClaude accesses customer conversations and support data to surface insights and draft responses. It helps support teams identify common issues and craft perfectly toned replies based on past interactions.\n\n**Project Management and Operations**\n\n11. Asana  \nClaude can create tasks, track project progress, and coordinate team goals without you ever leaving the conversation. You can turn a brainstorming session in Claude directly into actionable Asana tickets.\n\n12. Linear  \nFor product and engineering teams, Claude manages issues, writes detailed ticket descriptions, and tracks what is in progress across your team, keeping development workflows tightly integrated with your planning.\n\n13. Granola  \nClaude accesses your AI meeting notes so nothing from a call ever gets lost or forgotten. You can ask Claude to recall specific decisions made during a meeting last week and turn them into a project plan.\n\n**Automation and Infrastructure**\n\n14. Zapier  \nClaude can trigger Zapier automations directly via conversation, effectively connecting your actions across thousands of tools. This turns a simple chat prompt into a catalyst for complex, multi-step workflows.\n\n15. Make  \nSimilar to Zapier, Claude can run Make scenarios and manage your automation account directly from the chat, allowing for highly customized and visual workflow executions.\n\n16. n8n  \nFor those who prefer self-hosted or more technical automations, Claude accesses and runs your n8n workflows directly, bridging the gap between conversational AI and backend processes.\n\n17. Stripe  \nClaude can access payment data, financial reports, and infrastructure tools through your Stripe account. You can ask for revenue summaries or churn analysis without needing to navigate the Stripe dashboard.\n\n**Content and Design**\n\n18. Canva  \nClaude can create, autofill, and export Canva designs from a simple prompt. You do not even need to open the design tool to generate social media graphics or presentation slides.\n\n19. Gamma  \nClaude can create presentations, social posts, and landing pages through Gamma from a single prompt, dramatically accelerating the process of turning ideas into polished visual assets.\n\n20. MailerLite  \nClaude becomes your email marketing assistant, drafting campaigns and managing your MailerLite account directly, streamlining your newsletter and promotional workflows.\n\n**Pro Tips for Managing Connectors**\n\n1.Start small and scale up. You do not need to enable all 20 connectors on day one. Pick the three tools you use most frequently (like Google Drive, Slack, and Gmail) and build a habit of interacting with them through Claude first.\n\n2. Be specific with your search parameters. When asking Claude to pull information from a connector like Notion or Drive, provide date ranges, specific keywords, or folder names to help it find the exact context faster.\n\n3.Chain actions across connectors. The real magic happens when you combine tools. Ask Claude to read a brief in Google Drive (Connector 1), draft a project plan in Asana (Connector 2), and send a summary to the team in Slack (Connector 3) all in one prompt.\n\n4.Regularly audit your connections. Ensure that Claude only has access to the workspaces and folders you actually want it to read. Maintaining good data hygiene in your connected apps will result in much better outputs from Claude.\n\nYou might not need all 20 of these connectors for your specific business. But whatever your workflow requires, the ability to centralize it within Claude is a massive advantage.\n\nHave you tried any of these integrations yet? Which connector has saved you the most time? Let me know in the comments, and if you are looking for specific prompts to use with these tools / workflows, check out [PromptMagic.dev](http://PromptMagic.dev) \n\n","offTopic":false},{"id":"01d4116e-bc47-4629-bb5d-b8d662b63b83","excerpt":"Went down the MCP rabbit hole... — I am very much not a coder.\n\nI can manage html and css - I got started making websites on Geocities when I was like, nine - but actual coding was always another level beyond me. I could script kiddie it with the best of them but I didn't have the time or resources to really delve into","url":"https://www.reddit.com/r/ClaudeAI/comments/1u34ux8/went_down_the_mcp_rabbit_hole/","role":"demand","weight":1.0753974,"occurredAt":"2026-06-11T17:03:04.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"alternative_search","painScore":0.345,"sentiment":0.41935483,"confidence":0.79955196,"matchedPatterns":["switching_from","missing_feature"],"statement":"I was skeptical and am somewhat loathe to switch from something that I know works, and I gave it a shot.","title":"Went down the MCP rabbit hole...","body":"I am very much not a coder.\n\nI can manage html and css - I got started making websites on Geocities when I was like, nine - but actual coding was always another level beyond me. I could script kiddie it with the best of them but I didn't have the time or resources to really delve into computer programming.\n\nBut I knew about APIs. I always knew about APIS. It seemed like every website or, later, web app, had two sets of rules - what you could do via the UI.... and what you could do with the API. I wondered what it would be like to use the full power of an API - to simply \"command\" outcomes that were withheld from the \"normal\" user - but again.... no time, no resources, other priorities. Life.\n\nI got into WordPress a little bit, enjoying its balance between plug-and-play and extend-with-code, and discovered Gravity Forms about 15 years ago IIRC, which allowed me to take no-code to a whole other level. Again, all without APIs, unless it was baked into the UI.\n\nMore on that in a moment.\n\nWhen ChatGPT came out I started seeing what it could do, and quickly found that one of the things that it could do that I couldn't was write halfway decent code solutions for use cases that came up on a regular basis. Nothing worked perfectly out of the box but I can follow instructions, including debugging instructions, and I always got it to work eventually.\n\nAfter a year or so a programmer I know started gushing about Claude. I was skeptical and am somewhat loathe to switch from something that I know works, and I gave it a shot.\n\nMy use is primarily with the mobile app and web app. I don't use Claude Code or Cowork. But what I've been able to generate, output, produce, ship since making Claude my primary LLM has been astounding. What started as documents and code became anything that could be outputted as a series of characters. Entire forms, views, web pages all were spun up from within a conversation; complex documents, presentations, plans were developed and refined through conversation. And the code - again I'm no coder.... but the difference was obvious even to me.\n\nEverything was going fine, until I started missing my assistant.\n\nThe economy hit the company I work for hard, and we had to let go of all non-essential employees. I'm not exactly entry level but my assistant was definitely not essential, no matter how helpful it was to me to have someone assisting in the wings. But she was gone and my inbox was overflowing and, because I'd had success getting Claude to code a Google Apps script that connected my Google Tasks to our team Google Chat, I thought Claude might have some ideas for a Google Apps script for automatically organizing my inbox.\n\nClaude had other ideas.\n\nA Google Apps script was apparently \"too brittle\", and the recommended approach was actually something called an MCP - a way to connect Claude to Gmail via... APIs.\n\nTell me more about that... and it did.\n\nIt walked me through how to set up a basic MCP that runs off of WordPress. How to set up the Google Apps project and enable the APIs. Where to put the keys. Everything.\n\nI'm good at following instructions and follow instructions I did.\n\nIt was easy. Too easy. What about Google Task and Calendar?\n\nMore APIs, more instructions, more code snippets.\n\nI was getting the hang of this?\n\nWhat about the Gravity Forma API? What about the WordPress API itself?\n\nMore conversation, more instructions, more scripts.\n\nIt went on and on and on from there.... I spent days seeing what I could connect to Claude. I wound up connecting EVERYTHING in our operations that has an API to the MCP, from Google (Workspace + analytics + more) to Asana to DNS to server to more. Everything.\n\nNot all with write access lol. I'm not crazy. Once I got everything up and running, and showed it to my boss and the dev team, and mentioned how...interesting.... it was that Claude was autonomously writing, installing, and running diagnostic and helper code, we all agreed that safeguards need to be put in place and they devised an amazing tool approval gating system that, along with a bunch of other safeguards, keeps Claude in check. The MCP is now safely in their hands and they're continuing to extend it.\n\nBut in the week or so since we launched the MCP... My productivity has not 10x.\n\nIt's 100x. Projects that took weeks take hours. Projects that took days take minutes. With a very well-specified prompt, and a batching+complexity approach to working with Claude, I feel like I can move mountains. The gap between idea and outcome has shrunk in ways I never thought possible.\n\nAnd the APIs... I get all the APIs. I write a message to an LLM in a mobile app and Things Happen. All the things that I couldn't do since I never grew out of my script kiddie days... accessible and available and doable through clear human communication.\n\nThe work I've done assisted by this MCP blows my mind. With over 600 tools, mobile access, parallel instances on desktop, and an automations feature set (!), the MCP is a powerhouse. I'm still learning how to use it and I'm gratified to see other teams integrating it into their work as well.\n\nAnd with skills - that we can update and save with information and lessons learned from each trial and error / failure path Claude takes - we actually turned the MCP into a \\*learning\\* system. It doesn't start from zero in every conversation - it builds on the incremental progress of every intensive session we have with it before.\n\nMy mind is truly blown not just by how this MCP works for us but how it came to be in the first place. I'm still psychologically grappling with it lol. We truly are entering a different age.\n\nI wouldn't recommend anyone and everyone just diving down this rabbit hole and seeing how far they can take their productivity by enpowering and connecting Claude - if I didn't have a competent dev team behind me to review the code, install the safeguards, and take over the project, I don't think I would have left the MCP up. This level of connectivity and empowerment of an LLM is not rational or responsible without human review and oversight.\n\nBut dang... I've got a literally virtual assistant doing admin work, web work, marketing work, team work, and more.\n\nThis is pretty awesome.","offTopic":true},{"id":"9f30eb9f-1db6-4bc8-8814-45fd8c1ddb66","excerpt":"If You're Not Using These Things With CC, Then Maybe the Problem Is *You* — I wrote this as a slightly annoyed comment to a post earlier today, but I'm going to make it a post of its own because the comment got so long.\n\nAs preface, I studied CS in college, then went into industry for 3 years and then discovered vibe c","url":"https://www.reddit.com/r/ClaudeAI/comments/1nfa4kj/if_youre_not_using_these_things_with_cc_then/","role":"pain","weight":1.0693316,"occurredAt":"2025-09-12T17:58:51.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"problem_report","painScore":0.51,"sentiment":0.2,"confidence":0.70816666,"matchedPatterns":["terrible","product:supabase"],"statement":"Claude without planning mode is terrible unless you prompt it right (or update its output-style and Claude md files a lot).","title":"If You're Not Using These Things With CC, Then Maybe the Problem Is *You*","body":"I wrote this as a slightly annoyed comment to a post earlier today, but I'm going to make it a post of its own because the comment got so long.\n\nAs preface, I studied CS in college, then went into industry for 3 years and then discovered vibe coding tools the beginning of this year. I spend my weekends and evenings programming for fun, even before vibe coding was a thing, so I definitely spend a lot of time around these tools. For the last 4 months, AI has easily been writing about 95-99% of my code. I'm on the $200 plan, and burn from $500–1,300/month in api credits according to ccusage (not a brag—fuck those people who try to spend as much as they can—I don't do that, I'm just giving background). I mostly program in opus, but I make aggressive usage of agents which all use sonnet, so opus is mainly working as an orchestrator when doing big changes.\n\nI'm going to list some of the things I do, and if you're not doing every single one of them, it's possible that you're not using CC to its full potential:\n\n* Clear context aggressively. If you're going past 60k tokens, it's time to consider clearing chat and starting over\n   * On that note, if you're using more than 20k tokens of MCPs, you're crippling Claude. That would only give you a measly 20k tokens left of actual work before context is cooked.\n* Customize your Claude md files. Not just the top level one, but the ones in your sub directories too. If they're longer than a 100 lines, you're in the danger zone—especially true for the ones in subdirectories. This is a game about context management—every single piece of information you give Claude should be as context efficient as possible.\n* Get into this is making custom slash commands. Add markdown files to your commands directory inside \\~/.claude. For example, for a long time I really enjoyed this sequence of prompts where I had it build a documentation folder for a huge new feature where the prompt instructed it to create agents in parallel to go investigate independent pieces of code that were relevant to the new feature, document them, and save them to this shared directory. Then, I'd start a new  chat, and run a planning slash command. It had access to all the condensed, perfectly formatted documentation and would create a plan for parallel implementation. Then, I'd run implementation command, and it'd read the docs, the parallel plan, and it'd just be an agent that was spawning agents for each of the tasks in the parallel plan.\n* Customize your output styles. \\`/output-style:new description of your output-style\\` and then edit that file a ton. This is much more low level than a Claude md file. Include instructions in your output style about how to use your favorite MCP tools for your project, for example. Or your preferred workflow. Here's mine [https://gist.github.com/CaptainCrouton89/6a0a451e3c0fa8fbe759e2fdc9dd38c6](https://gist.github.com/CaptainCrouton89/6a0a451e3c0fa8fbe759e2fdc9dd38c6) .\n* Use subagents and delegate work. Context is a recurring theme here—if you have the main agent delegate, the new agent has fresh context, and the perfect prompt (created by an agent that had ALL the context but was too fried to implement).\n   * An example I use: A code-finder agent that uses haiku to search and find relevant context in the codebase and then returns it to the main agent. Quick way to get perfect codebase context.\n* Use planning mode. Claude without planning mode is terrible unless you prompt it right (or update its output-style and Claude md files a lot). However, if you start a new chat, put it in planning mode, and then go, Claude will absolutely cook.\n   * Don't just blindly approve the plan. if it's wrong, sometimes it's better to just copy and paste (or have Claude write its plan to an md file) and then start new chat. Building plans destroys context, so if there's a lot of plan building, it's good to start a new chat at the end.\n* Use hooks. I have hooks that tell Claude not to use fallbacks whenever my python script detects things that look like fallbacks in the code. That's one example among many—spend some time reading and understanding the top 3 reddit results from googling \"best claude code hooks\" and go from there.\n   * An example of more creative usage: whenever my message mentions enhancing/improving a prompt, then a prompt is injected that gives claude the path to a \"prompting-guide.md\" file I have on my computer, and tells claude to read that if it hasn't already. This pattern is great, because it's token efficient, but it brings claude up to speed on the latest/best prompting practices for when I have it iterate on a system prompt.\n* Build custom MCPs that only include the tools you need, and output hyper token efficient markdown. If you install the default supabase mcp, you're about to destroy your context. If you make your own, you can narrow it down to the three tools you actually use, and then tweak their outputs to be compressed markdown with helpful error messages. If you don't want to figure it out yourself, all my MCPs start with this: [https://github.com/CaptainCrouton89/mcp-boilerplate](https://github.com/CaptainCrouton89/mcp-boilerplate) . It's got a [CLAUDE.md](http://CLAUDE.md) file and a template and docs and installation commands. If you start a new chat and say, \"build an mcp for XYZ\" it'll work out of the box, I promise.\n* Use Markdown files. Someone reminded me in the comments, but markdown files are your conversation memory. They are the long term storage of claude code. Treat it as such, and tell claude to write to markdown, and then start a new conversation using that markdown as reference.\n* Use custom subagents. They let you save \"space\" in system prompt, by having all that custom system prompting you want for your frontend only be used on the frontend agent, rather than being wasted on your daily driver.\n* Read the Claude Code documentation and understand wtf you're using. Just like real devs read the actual documentation of the library that they primarily work with, real vibe coders read claude documentation and completely understand the tool they're using.\n\nThere are a good number of additional things (building workflows, how to write good system prompts, how to parallelize work with agents, some more I'm forgetting), but the ones listed above are what EVERYONE should be doing. **If you go down that list and you're doing every single one of those things (or at least nearly all) and you** ***still*** **think it sucks, let me know in the comments**—I wanna hear what's going on.\n\nI'm not shilling for Anthropic—I've switched tools a few times, and I'll switch again. If ya'll wanna switch, it legitimately drives CC to be a better product because competition is good. I just wanted to make this post because it's blown my mind how much hate the product has been getting, and I felt like sharing some productivity secrets out of the goodness of my heart.\n\n## Further Inspiration\n\nMy .claude directory. It's a mess, but I threw it on github after removing the keys for you guys cuz I love you all. Well, most of you. [https://github.com/CaptainCrouton89/.claude](https://github.com/CaptainCrouton89/.claude) . Mine it for whatever you want. I probably modify it a few times a week.\n\n## Quick Example\n\nAn example trace of CC one-shotting a medium-large feature after a very brief iteration on the plan (5-10 mins of independent work) [https://gist.github.com/CaptainCrouton89/cc2f3bb72465195b8c9f485980fbc84e](https://gist.github.com/CaptainCrouton89/cc2f3bb72465195b8c9f485980fbc84e) .","offTopic":false},{"id":"57192496-2408-4d75-8c3e-55f6737a9dd3","excerpt":"I pair-programmed ~22K lines of C with Claude Opus to fix one of Claude Code's biggest inefficiencies — You know the thing where Claude reads an entire 8000-line file just to look at one function? I got tired of watching 84K tokens vanish every time Claude needed to understand `initServer()` in a large C project. So I ","url":"https://www.reddit.com/r/ClaudeAI/comments/1rxz32s/i_pairprogrammed_22k_lines_of_c_with_claude_opus/","role":"request","weight":1.0222666,"occurredAt":"2026-03-19T12:28:58.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"problem_report","painScore":0.36,"sentiment":0.33333334,"confidence":0.75166667,"matchedPatterns":["manual_process"],"statement":"Way faster than reading docs or source manually.","title":"I pair-programmed ~22K lines of C with Claude Opus to fix one of Claude Code's biggest inefficiencies","body":"You know the thing where Claude reads an entire 8000-line file just to look at one function? I got tired of watching 84K tokens vanish every time Claude needed to understand `initServer()` in a large C project. So I spent a few weeks pair-programming with Claude Opus 4.6 to build something about it.\n\nThe result is **TokToken** — a single-binary CLI (written in C, no dependencies apart from installing ) that indexes your codebase and lets Claude retrieve only the symbols it actually needs. The whole thing runs as an MCP server, so Claude Code picks it up natively. No prompt engineering, no wrapper scripts. You add it to your MCP config and Claude just starts being smarter about how it navigates code.\n\nThe irony is obvious: Claude built the tool that makes Claude waste fewer tokens. And it works!\n\n**What actually changes in practice.** Instead of Claude reading whole files to find things, it searches a symbol index and pulls back just the code it needs. On the Redis codebase (727 files, 45K symbols), retrieving a single function costs 2,699 tokens instead of 84,193. That's one operation — multiply it across a real session where Claude explores 10-20 files and you start to see why this matters. I tested it on the Linux kernel too (65K files, 7.4M symbols) and the savings hold: 88-99% reduction consistently.\n\nBut it's not just about saving tokens on your own project. Some things I've been using it for that I didn't originally plan:\n\n- **Studying unfamiliar codebases.** I pointed it at a few open source projects I wanted to understand architecturally. Instead of Claude burning through context reading file after file, it searches for the entry points, traces the import graph, inspects the key abstractions — and still has context left to actually discuss what it found. It's like giving Claude a map instead of making it wander.\n- **Reviewing dependencies before adopting them.** Before pulling in a library, I'll index it and have Claude inspect the public API surface, check how errors are handled, look at what it actually depends on internally. Way faster than reading docs or source manually.\n- **Onboarding onto legacy code.** I've worked on projects where nobody remembers why half the code exists. Being able to say \"find every caller of this function\" or \"show me the class hierarchy under this base class\" and getting precise answers without burning the whole context window — that's been genuinely useful.\n- **Refactoring.** Before touching a function, Claude can check its blast radius — who calls it, who imports the file, what depends on it. With the full picture in a few hundred tokens instead of tens of thousands, it makes better refactoring suggestions.\n\nThe tool is in beta. It works well in my daily workflow, but I want to stress-test the MCP integration with more setups. I've tested extensively with Claude Code on VS Code, but there are a lot of MCP-compatible environments now and I can't cover them all alone.\n\nSetup takes about two minutes. The fastest way: tell Claude Code to read the [agentic integration docs](https://github.com/mauriziofonte/toktoken/blob/main/docs/LLM.md) and it will install and configure everything autonomously, including adding itself to your MCP config. Yes, Claude sets up the tool that Claude built to make Claude better. Turtles all the way down.\n\nIt's AGPL-3.0, fully open source, no SaaS, no telemetry, no accounts, no freemium. Single static binary. Code is pure C, deterministic, no LLM at runtime.\n\nI'm genuinely curious to hear from other Claude Code users. Does the MCP integration work in your setup? Does it actually help with context window pressure on your projects? And for those of you who've been building serious things with Claude: how far have you pushed it on systems-level code?\n\nSource: [github.com/mauriziofonte/toktoken](https://github.com/mauriziofonte/toktoken)","offTopic":true},{"id":"eeb93604-ee71-4125-8921-8df2611a20a3","excerpt":"The Complete Guide to Claude Code V4 — The Community Asked, We Delivered: 85% Context Reduction, Custom Agents & Session Teleportation — https://preview.redd.it/h0m40cj0wegg1.jpg?width=1920&format=pjpg&auto=webp&s=8f32bc241d525a08fad2da9be99bc3bc704e77b5\n\n# V4: The January 2026 Revolution\n\n# [View Web Version](https://","url":"https://www.reddit.com/r/ClaudeAI/comments/1qquxle/the_complete_guide_to_claude_code_v4_the/","role":"demand","weight":1.0096917,"occurredAt":"2026-01-30T03:59:58.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"alternative_search","painScore":0.33,"sentiment":0.5,"confidence":0.75916666,"matchedPatterns":["switching_from"],"statement":"Perfect for: * Switching from terminal to visual interface * Sharing session with collaborators * Continuing on a different device # Configure Remote Environment /remote-env Set up environment variables and configuration for remote session…","title":"The Complete Guide to Claude Code V4 — The Community Asked, We Delivered: 85% Context Reduction, Custom Agents & Session Teleportation","body":"https://preview.redd.it/h0m40cj0wegg1.jpg?width=1920&format=pjpg&auto=webp&s=8f32bc241d525a08fad2da9be99bc3bc704e77b5\n\n# V4: The January 2026 Revolution\n\n# [View Web Version](https://thedecipherist.com/articles/claude-code-guide-v4/?utm_source=reddit&utm_medium=post&utm_campaign=claude_code_v4&utm_content=r_claudeai)\n\n# Previous guides: [V1](https://www.reddit.com/r/TheDecipherist/comments/1qbkmx6/the_complete_guide_to_claude_code_global_claudemd/) | [V2](https://www.reddit.com/r/ClaudeAI/comments/1qcwckg/the_complete_guide_to_claude_code_v2_claudemd_mcp/) | [V3](https://www.reddit.com/r/ClaudeAI/comments/1qe239d/the_complete_guide_to_claude_code_v3_lsp_claudemd/)\n\nBecause of the overwhelming support on V1-V3, I'm back with V4. Huge thanks to everyone who contributed to the previous guides: u/BlueVajra, u/stratofax, u/antoniocs, u/GeckoLogic, u/headset38, u/tulensrma, u/jcheroske, and the rest of the community. Your feedback made each version better.\n\nClaude Code 2.1.x shipped 1,096+ commits in January alone. This isn't an incremental update - it's a fundamental shift in how Claude Code manages context, delegates work, and scales.\n\n**What's new in V4:**\n\n* **Part 9: MCP Tool Search** \\- 85% context reduction with lazy loading\n* **Part 10: Custom Agents** \\- Automatic delegation to specialists\n* **Part 11: Session Teleportation** \\- Move sessions between devices\n* **Part 12: Background Tasks** \\- Parallel agent execution\n* **Part 13: New Commands & Shortcuts** \\- `/config` search, `/stats` filtering, custom keybindings\n* Updated GitHub repo with V4 templates coming soon\n\n**TL;DR:** MCP Tool Search reduces context overhead by 85% (77K -> 8.7K tokens) by lazy-loading tools on-demand. Custom Agents let you create specialists that Claude invokes automatically - each with isolated context windows. Session Teleportation lets you move work between terminal and claude.ai/code seamlessly. Background Tasks enable parallel agent execution with Ctrl+B. And the new Setup hook automates repository initialization.\n\n# Table of Contents\n\n# Foundation (From V1-V3)\n\n* [Part 1: The Global CLAUDE.md as Security Gatekeeper](#part-1-the-global-claudemd-as-security-gatekeeper)\n* [Part 2: Global Rules for New Project Scaffolding](#part-2-global-rules-for-new-project-scaffolding)\n* [Part 3: MCP Servers - Claude's Integrations](#part-3-mcp-servers--claudes-integrations)\n* [Part 4: Commands - Personal Shortcuts](#part-4-commands--personal-shortcuts)\n* [Part 5: Skills - Reusable Expertise](#part-5-skills--reusable-expertise)\n* [Part 6: Why Single-Purpose Chats Are Critical](#part-6-why-single-purpose-chats-are-critical)\n* [Part 7: Hooks - Deterministic Enforcement](#part-7-hooks--deterministic-enforcement)\n* [Part 8: LSP - IDE-Level Code Intelligence](#part-8-lsp--ide-level-code-intelligence)\n\n# New in V4\n\n* [Part 9: MCP Tool Search - The 85% Context Revolution](#part-9-mcp-tool-search--the-85-context-revolution)\n* [Part 10: Custom Agents - Automatic Delegation](#part-10-custom-agents--automatic-delegation)\n* [Part 11: Session Teleportation](#part-11-session-teleportation)\n* [Part 12: Background Tasks & Parallel Execution](#part-12-background-tasks--parallel-execution)\n* [Part 13: New Commands, Shortcuts & Quality of Life](#part-13-new-commands-shortcuts--quality-of-life)\n\n# Reference\n\n* [Quick Reference](#quick-reference)\n* [GitHub Repo](#github-repo)\n* [Sources](#sources)\n\n# Part 1: The Global [CLAUDE.md](http://CLAUDE.md) as Security Gatekeeper\n\n# The Memory Hierarchy\n\nClaude Code loads CLAUDE.md files in a specific order:\n\n|Level|Location|Purpose|\n|:-|:-|:-|\n|**Enterprise**|`/etc/claude-code/CLAUDE.md`|Org-wide policies|\n|**Global User**|`~/.claude/CLAUDE.md`|Your standards for ALL projects|\n|**Project**|`./CLAUDE.md`|Team-shared project instructions|\n|**Project Local**|`./CLAUDE.local.md`|Personal project overrides|\n\nYour global file applies to **every single project** you work on.\n\n# What Belongs in Global\n\n**1. Identity & Authentication**\n\n    ## GitHub Account\n    **ALWAYS** use **YourUsername** for all projects:\n    - SSH: `git@github.com:YourUsername/<repo>.git`\n    \n    ## Docker Hub\n    Already authenticated. Username in `~/.env` as `DOCKER_HUB_USER`\n\n**Why global?** You use the same accounts everywhere. Define once, inherit everywhere.\n\n**2. The Gatekeeper Rules**\n\n    ## NEVER EVER DO\n    \n    These rules are ABSOLUTE:\n    \n    ### NEVER Publish Sensitive Data\n    - NEVER publish passwords, API keys, tokens to git/npm/docker\n    - Before ANY commit: verify no secrets included\n    \n    ### NEVER Commit .env Files\n    - NEVER commit `.env` to git\n    - ALWAYS verify `.env` is in `.gitignore`\n\n# Why This Matters: Claude Reads Your .env\n\n[Security researchers discovered](https://www.knostic.ai/blog/claude-loads-secrets-without-permission) that Claude Code **automatically reads** `.env` **files** without explicit permission. [Backslash Security warns](https://www.backslash.security/blog/claude-code-security-best-practices):\n\n>\"If not restricted, Claude can read `.env`, AWS credentials, or `secrets.json` and leak them through 'helpful suggestions.'\"\n\nYour global CLAUDE.md creates a **behavioral gatekeeper** \\- even if Claude has access, it won't output secrets.\n\n# Syncing Global [CLAUDE.md](http://CLAUDE.md) Across Machines\n\nIf you work on multiple computers, sync your `~/.claude/` directory using a dotfiles manager:\n\n    # Using GNU Stow\n    cd ~/dotfiles\n    stow claude  # Symlinks ~/.claude to dotfiles/claude/.claude\n\nThis gives you:\n\n* Version control on your settings\n* Consistent configuration everywhere\n* Easy recovery if something breaks\n\n# Defense in Depth\n\n|Layer|What|How|\n|:-|:-|:-|\n|1|Behavioral rules|Global CLAUDE.md \"NEVER\" rules|\n|2|Access control|Deny list in settings.json|\n|3|Git safety|.gitignore|\n\n# Team Workflows: Evolving [CLAUDE.md](http://CLAUDE.md)\n\n[Boris Cherny shares how Anthropic's Claude Code team does it](https://x.com/bcherny/status/2007179832300581177):\n\n>\"Our team shares a single CLAUDE.md for the Claude Code repo. We check it into git, and the whole team contributes multiple times a week.\"\n\n**The pattern:** Mistakes become documentation.\n\n    Claude makes mistake -> You fix it -> You add rule to CLAUDE.md -> Never happens again\n\n# Part 2: Global Rules for New Project Scaffolding\n\nYour global CLAUDE.md becomes a **project factory**. Every new project automatically inherits your standards.\n\n# The Problem Without Scaffolding Rules\n\n[Research from project scaffolding experts](https://github.com/madison-hutson/claude-project-scaffolding):\n\n>\"LLM-assisted development fails by silently expanding scope, degrading quality, and losing architectural intent.\"\n\n# The Solution\n\n    ## New Project Setup\n    \n    When creating ANY new project:\n    \n    ### Required Files\n    - `.env` - Environment variables (NEVER commit)\n    - `.env.example` - Template with placeholders\n    - `.gitignore` - Must include: .env, node_modules/, dist/\n    - `CLAUDE.md` - Project overview\n    \n    ### Required Structure\n    project/\n    ├── src/\n    ├── tests/\n    ├── docs/\n    ├── .claude/\n    │   ├── skills/\n    │   ├── agents/\n    │   └── commands/\n    └── scripts/\n    \n    ### Node.js Requirements\n    Add to entry point:\n    process.on('unhandledRejection', (reason, promise) => {\n      console.error('Unhandled Rejection:', reason);\n      process.exit(1);\n    });\n\nWhen you say \"create a new Node.js project,\" Claude reads this and **automatically** creates the correct structure.\n\n# Part 3: MCP Servers - Claude's Integrations\n\n[MCP (Model Context Protocol)](https://www.anthropic.com/news/model-context-protocol) lets Claude interact with external tools.\n\n# Adding MCP Servers\n\n    claude mcp add <server-name> -- <command>\n    claude mcp list\n    claude mcp remove <server-name>\n\n# When NOT to Use MCP\n\nMCP servers consume tokens and context. For simple integrations, consider alternatives:\n\n|Use Case|MCP Overhead|Alternative|\n|:-|:-|:-|\n|Trello tasks|High|CLI tool (`trello-cli`)|\n|Simple HTTP calls|Overkill|`curl` via Bash|\n|One-off queries|Wasteful|Direct command|\n\n**Rule of thumb:** If you're calling an MCP tool once per session, a CLI is more efficient. MCP shines for *repeated* tool use within conversations.\n\n**UPDATE V4:** With MCP Tool Search (Part 9), this tradeoff changes significantly. You can now have many more MCP servers without paying the upfront context cost.\n\n# Recommended MCP Servers for Developers\n\n# Core Development\n\n|Server|Purpose|Install|\n|:-|:-|:-|\n|**Context7**|Live docs for any library|`claude mcp add context7 -- npx -y @upstash/context7-mcp@latest`|\n|**GitHub**|PRs, issues, CI/CD|`claude mcp add github -- npx -y @modelcontextprotocol/server-github`|\n|**Filesystem**|Advanced file operations|`claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem`|\n|**Sequential Thinking**|Structured problem-solving|`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`|\n\n# Databases\n\n|Server|Purpose|Install|\n|:-|:-|:-|\n|**MongoDB**|Atlas/Community, Performance Advisor|`claude mcp add mongodb -- npx -y mongodb-mcp-server`|\n|**PostgreSQL**|Query Postgres naturally|`claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres`|\n|**DBHub**|Universal (MySQL, SQLite, etc.)|`claude mcp add db -- npx -y @bytebase/dbhub`|\n\n# Documents & RAG\n\n|Server|Purpose|Install|\n|:-|:-|:-|\n|**Docling**|PDF/DOCX parsing, 97.9% table accuracy|`claude mcp add docling -- uvx docling-mcp-server`|\n|**Qdrant**|Vector search, semantic memory|`claude mcp add qdrant -- npx -y @qdrant/mcp-server`|\n|**Chroma**|Embeddings, vector DB|`claude mcp add chroma -- npx -y @chroma/mcp-server`|\n\n# Browser & Testing\n\n|Server|Purpose|Install|\n|:-|:-|:-|\n|**Playwright**|E2E testing, scraping|`claude mcp add playwright -- npx -y @anthropic-ai/playwright-mcp`|\n|**Browser MCP**|Use your logged-in Chrome|[browsermcp.io](https://browsermcp.io)|\n\n# Cloud & DevOps\n\n|Server|Purpose|Install|\n|:-|:-|:-|\n|**AWS**|S3, Lambda, CloudWatch|`claude mcp add aws -- npx -y @anthropic-ai/aws-mcp`|\n|**Docker**|Container management|`claude mcp add docker -- npx -y @anthropic-ai/docker-mcp`|\n|**Kubernetes**|Cluster operations|`claude mcp add k8s -- npx -y @anthropic-ai/kubernetes-mcp`|\n\n# Part 4: Commands - Personal Shortcuts\n\nCommands are personal macros that expand into prompts. Store them in:\n\n* `~/.claude/commands/` \\- Available everywhere\n* `.claude/commands/` \\- Project-specific\n\n# Basic Command\n\nCreate `~/.claude/commands/review.md`:\n\n    ---\n    description: Review code for issues\n    ---\n    \n    Review this code for:\n    1. Security vulnerabilities\n    2. Performance issues\n    3. Error handling gaps\n    4. Code style violations\n\n**Usage:** Type `/review` in any session.\n\n# Command with Arguments\n\nCreate `~/.claude/commands/ticket.md`:\n\n    ---\n    description: Create a ticket from description\n    argument-hint: <ticket-description>\n    ---\n    \n    Create a detailed ticket for: $ARGUMENTS\n    \n    Include:\n    - User story\n    - Acceptance criteria\n    - Technical notes\n\n**Usage:** `/ticket Add dark mode support`\n\n# Advanced: Commands with Bash Execution\n\n    ---\n    description: Smart commit with context\n    allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)\n    argument-hint: [message]\n    ---\n    \n    ## Context\n    - Current git status: !`git status`\n    - Current git diff: !`git diff HEAD`\n    - Current branch: !`git branch --show-current`\n    - Recent commits: !`git log --oneline -5`\n    \n    ## Task\n    Create a commit with message: $ARGUMENTS\n\nThe `!` backtick syntax runs bash commands before the prompt is processed.\n\n# Part 5: Skills - Reusable Expertise\n\nSkills are **triggered expertise** that load only when needed. Unlike CLAUDE.md (always loaded), skills use progressive disclosure to save context.\n\n# Creating a Skill\n\nCreate `.claude/skills/code-review/SKILL.md`:\n\n    ---\n    name: Code Review\n    description: Comprehensive code review with securi","offTopic":true},{"id":"42cdf18d-f0db-461f-a4e2-70d909a87b88","excerpt":"Claude can now connect to 75 apps directly to help you get things done with awesome workflows using tools like Gamma, Clay, Canva,  Figma, Slack, Asana, Quickbooks, Hubspot, Salesforce, and many more — TLDR - view the attached short presentation to get a fast visual overview of how Claude connect apps work.\n\nClaude jus","url":"https://www.reddit.com/r/promptingmagic/comments/1qpwyuu/claude_can_now_connect_to_75_apps_directly_to/","role":"request","weight":1.0042068,"occurredAt":"2026-01-29T03:11:12.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"promptingmagic","intent":"problem_report","painScore":0.36,"sentiment":1,"confidence":0.73838735,"matchedPatterns":["manual_process"],"statement":"No more copy-pasting.","title":"Claude can now connect to 75 apps directly to help you get things done with awesome workflows using tools like Gamma, Clay, Canva,  Figma, Slack, Asana, Quickbooks, Hubspot, Salesforce, and many more","body":"TLDR - view the attached short presentation to get a fast visual overview of how Claude connect apps work.\n\nClaude just launched interactive apps powered by MCP (Model Context Protocol). You can now use Slack, Figma, Canva, Asana, and 100+ other tools DIRECTLY inside your Claude chat. No more copy-pasting. No more tab switching. Go to Settings then Connectors to browse and connect apps, or visit claude.ai/directory. The desktop app lets you set up custom MCP connections to literally anything. This is fundamentally different from ChatGPT's approach because Claude can actually WRITE to your apps, not just read from them. Available on Pro, Max, Team, and Enterprise plans at no extra cost.\n\n\n\nAnthropic just dropped what might be the most underrated AI feature of the year. Claude can now embed fully interactive third-party apps directly inside your conversations.\n\nThis is not another plugin directory announcement. This is your AI assistant becoming a genuine command center for your entire digital workspace.\n\nThink about your current workflow. You ask Claude something, it gives you an answer, then you copy that answer, switch tabs, paste it somewhere else, make edits, switch back, ask follow-up questions, repeat forever. That workflow is now obsolete.\n\n# How to Connect Apps\n\n**Web and Desktop App Method:**\n\n1. Open Claude\n2. Go to Settings\n3. Click Connectors\n4. Browse the available apps\n5. Click Connect on any app you want\n6. Authenticate with your existing account credentials\n7. Done. Claude now has access to that tool.\n\nAlternatively, go directly to [**claude.ai/directory**](http://claude.ai/directory) to browse everything in one place with beautiful interface previews.\n\n**Desktop App Local MCP Method:**\n\nThe Claude desktop app has a superpower most people do not know about. It can create its own MCP connections to literally anything on your computer or any service you want.\n\n1. Open Claude Desktop\n2. Go to Settings then Developer\n3. Add custom MCP server configurations\n4. Point it to local files, databases, custom APIs, internal tools\n\nThis is where power users are building genuinely custom AI workflows that connect Claude to proprietary internal systems.\n\n# The Launch Partner Apps (Interactive)\n\nThese nine apps launched with full interactive interfaces embedded in Claude:\n\n**Amplitude**: Build analytics charts, then explore trends and adjust parameters interactively to uncover hidden insights. You can literally click around the chart inside Claude.\n\n**Asana**: Turn conversations into projects, tasks, and timelines. Your team sees updates in Asana in real time while you chat.\n\n**Box**: Search for files, preview documents inline, extract insights and ask questions about content without ever opening Box itself.\n\n**Canva**: Create presentation outlines, then customize branding and design in real-time. Client-ready decks built entirely inside a chat.\n\n**Clay**: Enrich contact data and build prospect lists with live data updates appearing as you work.\n\n**Figma**: Turn text prompts into flow charts, Gantt charts, and diagrams within FigJam. Design workflows without opening Figma.\n\n**Hex**: Ask data questions and receive answers with interactive charts, tables, and citations. Real SQL-powered analysis in your chat.\n\n**Monday.com**: Manage projects, update boards, assign tasks, and visualize progress without leaving the conversation.\n\n**Slack**: Draft, edit, preview, and send messages in a formatted preview. See exactly what your message will look like before it goes out.\n\n# The Full Connector Directory (100+ Apps)\n\nBeyond the interactive launch partners, Claude connects to a massive ecosystem:\n\n**Productivity and Project Management**: Notion, Linear, Todoist, Trello, ClickUp, Basecamp\n\n**Communication**: Gmail, Outlook, Discord\n\n**Development**: GitHub, GitLab, Bitbucket, Jira, Confluence, Sentry\n\n**Design**: Adobe Creative Cloud, Miro, Whimsical\n\n**Data and Analytics**: Google Sheets, Airtable, Snowflake, BigQuery, Looker, Tableau\n\n**Finance**: Stripe, PayPal, QuickBooks, Xero\n\n**CRM**: Salesforce, HubSpot, Pipedrive, Intercom\n\n**Storage**: Google Drive, Dropbox, OneDrive\n\n**Developer Tools**: PostgreSQL, MySQL, Redis, Supabase, Firebase\n\n**And Many More**: The directory is constantly expanding as developers build new MCP servers.\n\n# Most Popular and High-Impact Connectors\n\nBased on community usage patterns and workflow value:\n\n**Tier 1 (Essential for most users)**:\n\n* Google Drive / Gmail (document and email access)\n* Notion (knowledge base and notes)\n* Slack (team communication)\n* GitHub (code and version control)\n\n**Tier 2 (Power user favorites)**:\n\n* Linear (issue tracking)\n* Figma (design to code)\n* Stripe (financial data)\n* Asana or Monday (project management)\n\n**Tier 3 (Specialized high-value)**:\n\n* Salesforce (sales workflows)\n* Snowflake or BigQuery (data analysis)\n* Confluence (documentation)\n* Intercom (customer support)\n\n# What is MCP and Why Does It Matter\n\nMCP stands for Model Context Protocol. Anthropic created and open-sourced it in late 2024. Think of it as USB-C for AI applications.\n\nBefore MCP, every AI integration was custom built. If you wanted Claude to talk to Slack, someone had to build a Claude-specific Slack integration. Want it to talk to Asana? Another custom integration. This does not scale.\n\nMCP creates a universal standard. Build one MCP server for your app, and ANY AI that supports MCP can connect to it. Claude, ChatGPT, local models, IDE extensions, anything.\n\nThe architecture is simple:\n\n* Your AI app is the MCP Host (client)\n* External tools run MCP Servers\n* They communicate via a standardized protocol\n* The AI discovers available tools and can invoke them\n\nThe new MCP Apps extension takes this further by allowing servers to deliver actual interactive user interfaces, not just data. This is why you can see and interact with Figma directly inside Claude now.\n\n**Key Stats**:\n\n* 10,000+ active public MCP servers\n* 97 million monthly SDK downloads\n* Adopted by OpenAI, VS Code, and others\n* Donated to the Linux Foundation for long-term governance\n\n# Claude Apps vs ChatGPT Connect Apps: The Real Comparison\n\nBoth platforms now support app integrations. But they work differently in important ways.\n\n**The Fundamental Difference: Read vs Write**\n\nChatGPT's connectors are often read-only. You can ask ChatGPT to look at your Linear issues or Notion pages. It pulls the data, helps you think, gives you suggestions. Then you copy the output and paste it back into the original app manually.\n\nClaude's MCP implementation supports write actions. You can paste a Linear issue link, work with Claude to refine it, and Claude edits it directly in Linear when you are done. No copy-paste required.\n\nThis sounds like a small difference. In practice, it changes everything about how fast you can work.\n\n**Architecture Comparison**\n\nChatGPT uses a mix of native integrations and plugin architecture. Many connections go through third-party middleware. The ecosystem is broader but less consistent.\n\nClaude uses MCP throughout. Since Anthropic created the protocol, their implementation is more mature. Connections are more direct and capabilities are more uniform across apps.\n\n**Interactive UI**\n\nChatGPT shows some embedded interfaces for certain apps.\n\nClaude's MCP Apps extension means ANY connected app can surface interactive UI if the developer builds it. The design canvas you see in Canva inside Claude is the actual Canva interface, not a Claude-built approximation.\n\n**Who Has More Apps**\n\nChatGPT has 60+ direct connectors plus thousands of GPTs and plugins.\n\nClaude has 75+ direct connectors in the directory plus 10,000+ community MCP servers you can connect via desktop.\n\nThe numbers are close. The real question is which apps matter for your workflow.\n\n**Enterprise Features**\n\nClaude allows Team and Enterprise admins to control which connectors are available and which tools Claude can invoke. Audit logs track everything.\n\nChatGPT Enterprise offers similar controls through its admin console.\n\nBoth are enterprise-ready, but Claude's protocol-first approach may offer more granular control.\n\n# Top Use Cases That Will Change How You Work\n\n**1. The Zero-Tab Workflow**\n\nInstead of: Claude in one tab, docs in another, Slack in another, project board in another\n\nNow: Everything happens in Claude. Ask it to pull your Notion brief, draft the deliverable, create the Canva visuals, update the Asana timeline, and draft the Slack announcement. One conversation, complete workflow.\n\n**2. Design to Code Pipeline**\n\nOld way: Designer hands off Figma file, developer asks questions, back and forth forever\n\nNew way: Paste Figma link into Claude. Ask it to analyze the design, check Linear for implementation requirements, reference your component documentation, and generate the initial React code. Handoff friction eliminated.\n\n**3. Customer Intelligence**\n\nOld way: Manually pull CRM data, check support tickets, review payment history, compile notes\n\nNew way: Ask Claude to find all Intercom conversations for a client, check Stripe for payment history, research new company contacts with Clay,. review their Asana project status, and create a Notion page for your quarterly business review. Hours of prep become minutes.\n\n**4. Content Creation at Scale**\n\nOld way: Research competitors, draft content, create visuals, schedule distribution, all in separate tools\n\nNew way: Claude researches via web, drafts in the conversation, creates graphics in Canva, and prepares social posts. Gamma creates presentations. You review and approve. Done.\n\n**5. Real-Time Data Analysis**\n\nOld way: Export data, load into analysis tool, build charts, screenshot results, paste into presentation\n\nNew way: Ask Claude to query your database via Hex, visualize the results interactively, and embed the insights directly into a Gamma presentation. Live data, instant visualization.\n\n# Pro Tips and Secrets\n\n**1. Chain Multiple Connectors in One Prompt**\n\nDo not ask Claude to do one thing at a time. Stack requests across multiple connected apps in a single message. Claude handles the orchestration.\n\nExample: Check my Google Calendar for this week, find related Notion docs for each meeting, create prep notes in a new Notion page, and add reminder tasks in Todoist.\n\n**2. Use the Desktop App for Sensitive Data**\n\nLocal MCP connections through the desktop app keep your data on your machine. Connect to local databases, file systems, and internal APIs without data ever leaving your environment.\n\n**3. Build Custom MCP Servers for Proprietary Tools**\n\nIf your company has internal tools, build an MCP server for them. The SDK is available in Python and TypeScript. Claude then has access to your entire internal ecosystem.\n\n**4. Disable Unused Connectors Per Conversation**\n\nIn Settings, you can toggle which connectors are active for specific conversations. This keeps Claude focused and prevents accidental actions in apps you did not intend to use.\n\n**5. Review Before Allowing Always**\n\nWhen Claude requests permission to use a tool, you see an approval prompt. Only click Allow Always for tools and actions you fully trust. For sensitive operations, approve each time.\n\n**6. Use Projects to Organize Connected Workflows**\n\nClaude Projects let you group conversations with specific contexts. Combine this with specific connector configurations for different work streams. Your marketing project has Canva and social tools active. Your dev project has GitHub and Linear.\n\n**7. The Figma to Code Shortcut**\n\nPaste a Figma link. Ask Claude to audit your design system for inconsistencies OR convert a specific component to production React code. The Figma connector understands design intent at a deep level.\n\n**8. Slack Message Previews Save Embarrassment**\n\nNever send a Slack message without seeing exactly how it will look. The preview feature in Claude shows formatting, mentions, and emoji rendering before you commit.\n\nWe are watching AI assistants evolve from conver","offTopic":true},{"id":"d4fa37a3-74c8-4c13-bbb3-7e59201559b4","excerpt":"MCP is NOT dead. But a lot of MCP servers should be. — The discourse last week got loud fast. Perplexity's CTO said they're moving away from MCP internally. Suddenly everyone had decided: \"MCP is dead, long live the CLI.\"\n\nI've been thinking about this a lot, not as a spectator, but as someone building systems where MC","url":"https://www.reddit.com/r/ClaudeAI/comments/1rwcxht/mcp_is_not_dead_but_a_lot_of_mcp_servers_should_be/","role":"demand","weight":0.9997167,"occurredAt":"2026-03-17T17:20:35.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"alternative_search","painScore":0.33,"sentiment":0.05263158,"confidence":0.75166667,"matchedPatterns":["switching_from"],"statement":"Perplexity's CTO said they're moving away from MCP internally.","title":"MCP is NOT dead. But a lot of MCP servers should be.","body":"The discourse last week got loud fast. Perplexity's CTO said they're moving away from MCP internally. Suddenly everyone had decided: \"MCP is dead, long live the CLI.\"\n\nI've been thinking about this a lot, not as a spectator, but as someone building systems where MCP is a core architectural choice.\n\nHere's my take.\n\n# First, the criticism that's actually right\n\nFor well known tools like git, GitHub, AWS, Jira, kubectl, the CLI argument is largely correct. These tools have battle-tested CLIs. Agents were trained on millions of Stack Overflow answers, man pages, and GitHub repos full of shell scripts. When you tell Claude to run \\`gh pr view 123\\`, it just works. It doesn't need a protocol layer. It already knows the tool.\n\nCLIs are also debuggable in a way MCP isn't. When something goes wrong, you can run the same command yourself and see exactly what the agent saw. With MCP you're digging through JSON transport logs. That's real friction.\n\nThe composability point is fair too. Piping \\`terraform show -json\\` through \\`jq\\` to filter a plan is the kind of thing that's genuinely awkward to replicate in MCP. CLIs compose. That matters.\n\nSo if you've built an MCP server that's a thin wrapper around your REST API, and your tool already has a good CLI with years of documentation behind it, you should probably reconsider. The agent doesn't need the MCP layer. You added complexity for no real gain.\n\n# The context bloat problem\n\nEvery MCP server you add loads all its tool definitions into the agent's context window upfront, before any work starts. For a large API this gets absurd fast. Cloudflare's full API would consume over a million tokens just to load the menu. That's not theoretical friction, it's a real cost that compounds when you're running multiple servers.\n\nBut this is actively being solved, and the solution is interesting. Cloudflare's Code Mode approach reduces a million token API surface to about 1,000 tokens by giving the agent just two tools and letting it write code against the API rather than calling tools one by one. Anthropic independently converged on the same pattern.\n\nContext bloat is an implementation problem, not a protocol problem. Badly designed MCP servers with hundreds of loosely described tools will eat your context. Well-designed ones with focused, purposeful tool sets don't.\n\nAnd the constraint itself is shrinking. Anthropic just made a 1 million token context window generally available at standard pricing, five times the previous limit, no surcharge. The math on context bloat changes considerably at that scale.\n\n# Where the \"MCP is dead\" take falls apart\n\nEvery example in these posts is a tool the agent already knows. That's not a coincidence, it's the entire foundation of the argument. \"Give agents a CLI and some docs and they're off to the races\" only works when the agent already has the training data.\n\nWhat about something you built yourself? A custom workflow system, a proprietary platform, a new product that exists nowhere in any training corpus?\n\nA CLI can still work there. You document your tool in a CLAUDE md file, the agent reads it at session start, and it knows how to use your commands. Teams do this in production. It's a legitimate approach.\n\nBut there's a meaningful difference between documentation and a contract. With a CLI and CLAUDE md, you're writing instructions you're hoping the agent follows correctly. The agent can misread them or ignore them. Nothing enforces the interface.\n\nWith MCP, the tool definitions are the interface. Names, parameters, types, descriptions, all structured and enforced by the protocol itself. The agent can't call your tool with the wrong parameters because the schema won't allow it. You define the contract once and every session starts from a place of certainty rather than a place of trust. For simple tools that's a minor distinction. For anything where a wrong call has real consequences, that difference is the whole thing.\n\n# What MCP is actually for\n\nMost of the early MCP wave was companies shipping servers as proof they were \"AI first.\" Thin wrappers around REST APIs. A create\\_issue tool. A get\\_record tool. Data in, data out. For that use case the CLI critics are right. It's an awkward abstraction over something that already worked.\n\nBut that's not what MCP was designed for at its best. The tools that genuinely justify it are the ones where:\n\n* The state is live and shared. A design canvas a human is watching while an agent manipulates it. A session that carries context the agent needs mid-work. A surface where what's true right now matters, not just what's in a database.\n* There are two users. Not just the agent, but a human and an agent operating on the same system simultaneously. The human sets intent. The agent executes. The protocol is what makes both parties coherent. A CLI serves one user at a time. MCP can serve both.\n* The workflow is the value, not the data access. Orienting an agent at session start. Loading relevant context at the right moment. Enforcing behavioral conventions that make the agent effective, not just capable. None of that is data access. None of it maps cleanly to CLI commands.\n\nI'm building a system that is exactly this: dual-user, stateful, workflow-driven. The MCP server isn't there to give an agent access to data. It's there to make the agent oriented and behaviorally consistent across sessions, while a human steers from the other side. You couldn't replicate that with a CLI, not because the commands couldn't exist, but because the session-aware, stateful orchestration layer has no CLI equivalent.\n\nPaper Design is a good example of this done right.. Their MCP server is bidirectional, agents read from and write to a live canvas while a human designer watches and steers. That's not a thin API wrapper. That's a shared surface with two users and live state. MCP is genuinely the right call there.\n\n# CLI or MCP - how to decide\n\nMCP vs CLI isn't a protocol war. It's a question of fit.\n\n**Use a CLI when:**\n\n* The tool is well-known and the agent has training data on it\n* You want composability with other shell tools\n* Debuggability matters and you want to run the same command yourself\n\n**Use MCP when:**\n\n* You're building something custom with no training data behind it\n* The state is live and needs to persist across tool calls in a session\n* A human and an agent are both users of the same system\n* The protocol is the workflow, not just a path to data\n\nThe first wave of MCP was mostly companies slapping a protocol layer on top of their existing APIs. A lot of those servers should become CLIs or direct API calls. The critics are right about that.\n\nBut the second wave, stateful, workflow-aware, dual-user systems, that's where MCP earns its existence. Writing it off because the first wave was mostly unnecessary is like saying electricity was a bad idea because the first lightbulbs burned out quickly.\n\nThe protocol isn't dying. The bad implementations are being correctly identified as bad. Those are very different things.","offTopic":true},{"id":"d855cd23-58e5-45fd-bd6c-d3cba6af8346","excerpt":"Built an MCP server so Claude Code / Cursor / Antigravity stop forgetting my project every time I switch tools — is this actually useful or does something already do this? — I keep bouncing between Claude Code and Cursor on the same project, and every switch means re-explaining the stack, why we made certain decisions,","url":"https://www.reddit.com/r/MCPservers/comments/1vunq03/built_an_mcp_server_so_claude_code_cursor/","role":"pain","weight":0.9374321,"occurredAt":"2026-08-21T18:01:39.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"MCPservers","intent":"problem_report","painScore":0.62666667,"sentiment":-0.6666667,"confidence":0.57629025,"matchedPatterns":["manual_process"],"statement":"No more copy-pasting a CLAUDE.md between tools.","title":"Built an MCP server so Claude Code / Cursor / Antigravity stop forgetting my project every time I switch tools — is this actually useful or does something already do this?","body":"I keep bouncing between Claude Code and Cursor on the same project, and every switch means re-explaining the stack, why we made certain decisions, and what bugs are already fixed. So I built a small MCP server that stores that stuff once — decisions, conventions, known issues — and any MCP-compatible tool can read/write to it. No more copy-pasting a CLAUDE.md between tools.\n\nIt's local-first, SQLite-backed, open source. Right now it's single-project/single-user — logging is manual (log\\_decision, log\\_bug\\_fix, fetch\\_context).\n\nBefore I sink more time in: has anyone hit this specific pain (not general AI memory, specifically cross-tool coding context)? Is a maintained CLAUDE.md/.cursorrules genuinely enough for you, or is there real appetite for something that updates itself? What would make you actually keep using this after week one?","offTopic":false},{"id":"ac532157-7ac7-415b-9bec-085ece901fcd","excerpt":"Recent Claude Code Updates Reveal Anthropic's Agentic Vision — The changes that Anthropic has been making to Claude Code for the past few weeks indicate that Anthropic is building something much more powerful and sophisticated than what we're used to. More than just a coding agent capable of [rewriting multimillion-lin","url":"https://www.reddit.com/r/ClaudeAI/comments/1vtsf5g/recent_claude_code_updates_reveal_anthropics/","role":"demand","weight":0.9115975,"occurredAt":"2026-08-20T18:55:27.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"alternative_search","painScore":0.26904526,"sentiment":0.6666667,"confidence":0.7183333,"matchedPatterns":["switching_from","free_tier"],"statement":"Claude Code is moving from chatting back and forth to persistent, event-driven agents Anthropic's effort in the work that continues beyond one synchronous turn is phenomenal.","title":"Recent Claude Code Updates Reveal Anthropic's Agentic Vision","body":"The changes that Anthropic has been making to Claude Code for the past few weeks indicate that Anthropic is building something much more powerful and sophisticated than what we're used to. More than just a coding agent capable of [rewriting multimillion-line codebases](https://bun.com/blog/bun-in-rust), it's turning into an **agent \"operating system\"**, an extensible and **event-driven** harness with **safe, responsible** autonomy in which agents are now **persistent** and can coordinate work across **multiple sessions and devices**, create collaborative **artifacts**, and respond to external events.\n\nAs the power increases, so does the responsibility, so Anthropic is developing and tightening Claude Code's security with stronger approval, authority, sandboxing, and enterprise controls to keep that growing autonomy in check.\n\nThe long term vision seems to be unfolding as a **complete control plane** for software development, instead of just a powerful development assistant, making every part of it—research, design, planning, review, coordination, implementation, testing, delivery, maintenance, and support—easier, faster, less error-prone.\n\n# 1. Artifacts are becoming a powerful interface for working with agents\n\nThe most persistent theme is the rapid expansion of artifacts with documents, spreadsheets, slide decks, multi-artboard [Claude Design](https://claude.ai/design) canvases, whiteboards, diagrams, clickable prototypes, interactive decision components, comments, review threads, acknowledgements, asset storage, per-viewer data, publishing, versioning, watches, remote wakeups, and conflict-safe collaborative saving. ([v2.1.221](https://github.com/Piebald-AI/claude-code-system-prompts/commit/ff459f4#diff-39c74a3f1476df1ee66e03a6783d5e2c6f9b6336e65a12494d55b7b0aee9183c), [v2.1.228](https://github.com/Piebald-AI/claude-code-system-prompts/commit/b718060), [v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc), [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614), [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\nThis is far beyond a simple PDF or Word doc.  We're looking at a runtime where Claude can display prototypes, suggest ideas, present accomplishments, receive decisions, and incorporate feedback in a sophisticated interactive UI purpose-built case by case.\n\nBesides that, a \"document Artifact\" isn't just generated prose. It's a collaborative editor with ownership, feedback, save behavior, and conflict handling, introduced as *\"a live working document that looks and edits like a word processor page, published for the team to read, edit in place, and comment on — a memo, proposal, plan, spec, or meeting notes\"* for when the user wants *\"a document others will read or weigh in on, rather than a chat reply, a local file, or a finished report meant to be read top-to-bottom.\"* ([v2.1.228](https://github.com/Piebald-AI/claude-code-system-prompts/commit/b718060), [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\nA \"spreadsheet Artifact\" has persistent rows and cells, formulas, sorting, comments, and saved scratch state, introduced as *\"a live working sheet that looks and edits like a spreadsheet app, published for the team to read, edit cell-by-cell, sort, and comment on — a budget, tracker, roster, or comparison\"*. ([v2.1.228](https://github.com/Piebald-AI/claude-code-system-prompts/commit/b718060))\n\nA \"Design Artifact\" (Claude Design) has artboards, reusable components, design-system matching, static or clickable behavior, and explicit save and export capabilities.  It was introduced as *\"a multi-artboard visual design published as an Artifact that runs Claude Design's canvas editor\"*, calling the latter ***\"an early preview of Claude Design inside Claude Code\"***.  The 935-line skill covers creating design canvases—how they work internally; designing, authoring, seeding, checking, publishing, and handing over designs; how to update existing canvases; how to work with the user's inputs and existing brand and design; all the details of how to design UIs precisely. ([v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc), [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614))\n\nThe long-term value isn't just that Claude can make documents—models have been doing that since the beginning—it's that in addition to the content, Claude can now construct the **interface** most appropriate for the work: a styled page for code review findings or a set of designs for idea prototyping.\n\nArtifacts are forming Claude's generative UI layer. Live, dedicated surfaces that remain editable and collaborative even after the initial response. ([v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc); [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\n# 2. Claude Code is moving from chatting back and forth to persistent, event-driven agents\n\nAnthropic's effort in the work that continues beyond one synchronous turn is phenomenal.  There are background conversations and agents, forked sessions with separate Git worktrees, self-hosted runners, cloud and remote sessions, shell execution on remote devices, cross-session messaging, queued notifications, scheduled and webhook-triggered activity, artifact watches, background monitors, durable wake subscriptions, coordinator and worker-agent behavior and verifiable multi-turn goals. ([v2.1.221](https://github.com/Piebald-AI/claude-code-system-prompts/commit/ff459f4); [v2.1.227](https://github.com/Piebald-AI/claude-code-system-prompts/commit/1314a83); [v2.1.228](https://github.com/Piebald-AI/claude-code-system-prompts/commit/b718060); [v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc); [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))  Together they form a machine that humans supervise and steer rather than instruct turn by turn.\n\nThis architecture is increasingly event-driven. An agent can begin work, continue in the background, receive a GitHub notification, observe an Artifact comment, wake after a republish, react to a scheduled trigger, and pass a result to another agent, all in one session. ([v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc); [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\nThe notification changes are fascinating. Anthropic is developing how trust depends on the sender, when a background monitor should interrupt the user, which events materially change what the user should do next, how sessions on other machines or in the cloud exchange messages, what happens when a remote or cloud session isn't able to reply directly, and more. ([v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc); [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\nThe new Claude Code is beginning to resemble a distributed task system in which agents have identities, capabilities, queues, states, communication channels, and execution locations, similar to Hermes Agent/OpenClaw, but designed for every aspect of software development and product delivery.\n\n# 3. With great power comes great responsibility: increased autonomy paired with powerful safeguards\n\nMany of the least visible changes are about distinguishing information from authorization. ([v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614))\n\nClaude is repeatedly told to treat web content, comments, selected text, remote logs, browser content, cross-session messages, filenames, and tool-generated metadata as potentially untrusted. ([v2.1.221](https://github.com/Piebald-AI/claude-code-system-prompts/commit/ff459f4); [v2.1.222](https://github.com/Piebald-AI/claude-code-system-prompts/commit/911caf9); [v2.1.229](https://github.com/Piebald-AI/claude-code-system-prompts/commit/37fb9dc); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c)) These sources are used to inform the work, of course, but they don't automatically become instructions or grant consent. ([v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614))\n\nThis matters since Claude can now roam independently across shells, browsers, repositories, remote devices, and external connectors.  The resulting risk is much higher than before, and we still hear stories of powerful models losing their minds, like how [GPT-5.6 Sol deleted someone's home directory](https://x.com/mattshumer_/status/2076794038456385546).  The sandbox, credential masking, network controls, browser protections, prompt auditing, and approval checks all support the same strategy. ([v2.1.221](https://github.com/Piebald-AI/claude-code-system-prompts/commit/ff459f4); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\nAnthropic is pursuing nearly unrestricted autonomy—Claude can act with unlimited strength to do whatever it needs to complete an established goal, but anything consequential, especially dangerous/destructive actions, are prohibited. ([v2.1.221](https://github.com/Piebald-AI/claude-code-system-prompts/commit/ff459f4); [v2.1.232](https://github.com/Piebald-AI/claude-code-system-prompts/commit/a21a614); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\n# 4. Enterprises are getting more attention\n\nSeveral additions clearly point toward controlled organizational deployments like their customer-routed inference, short-lived, audience-specific tokens, cloud and remote sessions, etc.  Combined, these features let security and platform teams control where inference goes, where execution occurs, which credentials are used, which tools and skills are available, and what policies can block an operation.  ([v2.1.227](https://github.com/Piebald-AI/claude-code-system-prompts/commit/1314a83); [v2.1.228](https://github.com/Piebald-AI/claude-code-system-prompts/commit/b718060); [v2.1.233](https://github.com/Piebald-AI/claude-code-system-prompts/commit/2f5e820); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\nCustomer-routed inference is quite revealing since it separates organizational routing and credentials from the client itself. ([v2.1.228](https://github.com/Piebald-AI/claude-code-system-prompts/commit/b718060)) Combined with self-hosted execution and managed configuration, it positions Claude Code as an enterprise-controlled agent execution layer in companies, in addition to working with individual developers. ([v2.1.227](https://github.com/Piebald-AI/claude-code-system-prompts/commit/1314a83); [v2.1.233](https://github.com/Piebald-AI/claude-code-system-prompts/commit/2f5e820); [v2.1.234](https://github.com/Piebald-AI/claude-code-system-prompts/commit/373b98c))\n\n# /exit\n\nClaude Code is evolving from a fully-featured coding agent with plugins, skills, hooks, and slash commands to three connected layers: execution (shells, browsers, background, remote devices, cloud sessions, self-hosted runners), interaction (artifacts, documents, spreadsheets, slides, prototypes, designs, notifications), and governance (sandboxes, managed settings, )\n\nAnthropic is apparently betting that the winning coding agent will be the one that can manage long running work across tools, people, sessions, machines, and organizational boundaries—safely—the best.\n\nOf course, writing code is still pivotal, but the boundaries of Claude Code's capab","offTopic":true},{"id":"6c6f0ff1-6a2e-4230-8770-3a287670a020","excerpt":"The AI Agent Stack in 2026: How MCP Servers, CLI Tools, and Agent Skills Work Together (and Why You Need All Three) — In early 2025, building reliable AI agents often felt like assembling IKEA furniture without instructions: you had powerful models, but connecting them to real tools, data, and workflows was fragmented,","url":"https://www.reddit.com/r/AgentContext_dev/comments/1v7vgax/the_ai_agent_stack_in_2026_how_mcp_servers_cli/","role":"request","weight":0.90682614,"occurredAt":"2026-07-27T09:30:45.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"AgentContext_dev","intent":"problem_report","painScore":0.39,"sentiment":0.47826087,"confidence":0.6523929,"matchedPatterns":["workaround"],"statement":"Every integration required custom glue code.","title":"The AI Agent Stack in 2026: How MCP Servers, CLI Tools, and Agent Skills Work Together (and Why You Need All Three)","body":"In early 2025, building reliable AI agents often felt like assembling IKEA furniture without instructions: you had powerful models, but connecting them to real tools, data, and workflows was fragmented, brittle, and token-hungry. Every integration required custom glue code. Security was an afterthought. Context windows filled up fast. Agents hallucinated workflows or failed on edge cases.\n\nBy mid-2026, the landscape has matured dramatically. Three distinct but complementary approaches dominate production agent stacks: **MCP servers** (Model Context Protocol), **CLI tools**, and **Agent Skills**. They are not rivals in a zero-sum fight. They solve different layers of the agentic stack.\n\nMCP provides standardized, secure access to external systems. CLI tools deliver lightweight, training-data-leveraged execution for local operations. Agent Skills package procedural knowledge, domain expertise, and reliable workflows that agents can discover and load on demand.\n\nThe winning teams in 2026 don’t pick one - they orchestrate all three. This article breaks down each approach based on authoritative sources, real evaluations, and production patterns, then shows exactly how to use them effectively right now.\n\n### What Is the Model Context Protocol (MCP)?\n\nMCP is an open standard, originally developed by Anthropic and open-sourced in November 2024. It was later donated to the Agentic AI Foundation under the Linux Foundation for vendor-neutral governance. Think of it as **USB-C for AI agents** or the Language Server Protocol (LSP) for LLMs.\n\nBefore MCP, every AI client (Claude, Cursor, custom agents, etc.) needed bespoke adapters for every tool or data source. MCP standardizes the conversation: any compliant client can talk to any compliant server using JSON-RPC 2.0 over stdio (local) or streamable HTTP (remote/enterprise).\n\nAn **MCP server** is a lightweight program that exposes three core primitives to agents:\n- **Tools**: Typed, callable actions (e.g., “create GitHub issue,” “query database,” “send Slack message”). The server validates inputs and executes them.\n- **Resources**: Contextual data (files, database records, API responses) that agents can read.\n- **Prompts**: Reusable templates or workflows that users or agents can invoke.\n\nThe server handles authentication, rate limiting, and business logic. The agent never sees raw credentials or implementation details - it just calls typed functions.\n\n**Key benefits**:\n- Interoperability: One server works across Claude Desktop, Cursor, ChatGPT, custom agents, etc.\n- Discoverability and type safety.\n- Centralized governance (especially over HTTP with OAuth).\n- Rich ecosystem: Thousands of community and official servers for GitHub, Slack, databases, browsers, and more.\n\nIn 2026, MCP is mature. Local stdio servers remain popular for development, while HTTP-based enterprise deployments handle authentication, auditing, and multi-user scenarios.\n\n### What Are CLI Tools in the Agent Context?\n\nCLI tools are the oldest and simplest way to give agents real-world power: let the agent generate and execute shell commands (`git commit`, `docker build`, `kubectl apply`, `aws s3 sync`, etc.) and read the output.\n\nMany modern coding agents (Cursor, Claude Code, Aider-style setups, etc.) include a shell or code-execution environment. The model leverages its massive training data on common CLIs - it already “knows” how `git` or `jq` work without needing explicit schemas.\n\n**Strengths**:\n- Extremely low context cost for well-known tools.\n- Natural composability (pipes, scripts, one-liners).\n- Transparent debugging (you see the exact commands).\n- No extra server to run or maintain.\n\n**Limitations**:\n- Security model assumes the agent inherits the user’s permissions and environment variables.\n- Poor for remote or multi-tenant scenarios.\n- Less structured than typed tools.\n\n### What Are Agent Skills?\n\nAgent Skills (launched by Anthropic in October 2025 and published as an open standard in December 2025) are organized folders or directories containing a `SKILL.md` file plus supporting scripts, templates, and reference materials.\n\nA Skill is essentially a **portable onboarding manual** for a specific domain or workflow. It describes:\n- When the skill should trigger.\n- Step-by-step procedures.\n- Error handling and escalation rules.\n- Team conventions and quality standards.\n\nCrucially, Skills use **progressive disclosure**: only the name and short description load into the system prompt initially (roughly 30-50 tokens per skill). The full content loads only when the agent decides it’s relevant. Skills are loaded by the agent inside its working environment. They can include scripts and resources that the agent may execute or consult, but the Skill itself is mainly a portable package of instructions and supporting files, not a standalone service.\n\nOfficial Anthropic guidance is clear: **MCP gives access; Skills teach what to do with that access**.\n\n### Head-to-Head Comparison\n\nHere’s how the three approaches stack up across the dimensions that matter most in 2026.\n\n**Context / Token Efficiency**  \nCLI wins for mature tools (near-zero cost - the model already knows them). Skills are excellent thanks to lazy loading. Naive MCP can be expensive (hundreds of tokens per tool loaded every turn), but modern optimizations (tool search, per-session toggling, code-execution patterns with filesystem modules) deliver massive savings - one Anthropic-measured benchmark showed a 98.7% token reduction.\n\n**Security & Governance**  \nMCP excels here. Credentials live on the server (never in the agent’s context or outputs). HTTP mode supports per-user OAuth, audit logs, and role-based access. CLI inherits whatever the user’s shell has - fine for solo developers, risky in teams or regulated environments. Skills themselves are neutral; security depends on what they invoke.\n\n**Discoverability & Structure**  \nMCP offers the strongest typed schemas and automatic discovery. CLI relies on `--help` and training data. Skills rely on metadata + the agent’s judgment.\n\n**Performance & Reliability on Complex Tasks**  \nEvaluations (including head-to-head tests on analytical and coding workflows) show correctness is often similar across approaches when well-implemented. However, on hard open-ended tasks, poorly optimized MCP could cost 5-6× more in tokens and time than optimized alternatives. Short, opinionated Skills frequently outperform long, encyclopedic ones.\n\n**Setup & Maintenance**  \nCLI: Almost zero extra work.  \nSkills: Create Markdown + optional scripts (very low friction).  \nMCP: Requires building or installing a server (higher initial effort, but reusable across clients).\n\n### When to Use Each (Decision Framework)\n\nUse this simple framework:\n\n- **Need local operational execution on well-known tools** (git, docker, kubectl, jq, etc.) and the agent runs in a trusted single-user environment? → **CLI first**.\n- **Need to encode team processes, domain expertise, error handling, or multi-step judgment** (how we review PRs, how we prepare meeting notes, how we run financial analysis according to our standards)? → **Agent Skills**.\n- **Need secure, governed access to external systems** (databases, SaaS platforms, internal APIs) where credentials must stay isolated, or you want one integration that works across multiple agent clients? → **MCP server**.\n- **Building something reusable across teams or shipping to customers**? → Lean toward MCP (especially HTTP) + Skills.\n\n**Most powerful setups combine them**:\n- An MCP server gives the agent access to Notion or GitHub.\n- A Skill teaches it *your team’s specific workflow* for using that access (which pages to check first, what format to use, how to handle conflicts).\n- CLI handles quick local file operations or git commands that the Skill orchestrates.\n\n### The Winning Pattern in 2026: Layered Hybrid Architectures\n\nProduction teams have converged on this stack:\n1. **MCP layer** - for external connectivity and governance.\n2. **Skills layer** - for procedural intelligence and consistency.\n3. **CLI / code execution layer** - for lightweight local operations where it makes sense.\n\nA Skill can call MCP tools or CLI commands as part of its workflow. One MCP server can be enhanced by multiple Skills. This separation of concerns makes agents both capable *and* reliable.\n\nReal-world examples from 2026 deployments:\n- A financial services agent uses an MCP server for live market data + a Skill that enforces the firm’s valuation methodology and compliance checks.\n- A developer agent uses CLI for `git` operations + Skills for “our code review standards” + MCP for GitHub issue/PR management with proper auth.\n- Enterprise coding platforms expose internal tools via MCP gateways while providing Skills that capture institutional knowledge.\n\n### How to Get Started in 2026\n\n**Using Existing MCP Servers**  \nMost popular clients (Claude Desktop, Cursor, etc.) have simple config files where you add servers by command or URL. Popular ones include official GitHub, Slack, filesystem, and browser servers. Check the growing ecosystem on GitHub (modelcontextprotocol/servers) or community directories.\n\n**Building Your Own MCP Server**  \nUse official SDKs:\n- Python: `FastMCP` (very concise with decorators).\n- TypeScript: Official `@modelcontextprotocol/sdk`.\n\nA minimal server can be written in a few dozen lines. Expose tools with clear schemas, add resources for data, and prompts for common workflows. Test locally with stdio, then deploy HTTP with proper auth for production.\n\n**Creating Agent Skills**  \nCreate a folder with `SKILL.md` at the root. Write clear instructions: triggers, steps, examples, error handling. Add scripts or reference files as needed. Upload or place in the agent’s environment. Skills are portable across compliant platforms.\n\n**CLI Access**  \nEnsure your agent environment has shell or code execution enabled (most coding-focused agents do by default). For custom tools, consider wrapping them as simple scripts the agent can discover.\n\n### Challenges and Best Practices\n\n- **Context bloat** - Always prefer lazy loading patterns. Monitor token usage.\n- **Security** - Never give broad shell access in multi-user scenarios without isolation. Use MCP for anything sensitive.\n- **Skill quality** - Short and opinionated beats long and generic. Test Skills rigorously.\n- **Over-reliance on one layer** - Pure MCP without Skills leads to generic, inconsistent behavior. Pure CLI without structure leads to fragile scripts.\n- **Observability** - Log tool calls, skill invocations, and outcomes. Use evaluation frameworks (many teams now run LLM-as-judge evals on agent trajectories).\n\n### The Road Ahead\n\nMCP continues to mature as the connectivity standard. Skills are evolving toward agent-authored and self-improving versions. CLI remains the pragmatic choice for local power tools. The biggest advances in the second half of 2026 will likely come from better orchestration layers that intelligently route between these three primitives and from richer evaluation tooling.\n\nThe era of “just prompt the model harder” is over. The agents that win are those built on clear architectural layers.\n\n### Sources and Further Reading\n\n- Anthropic. \"Extending Claude’s capabilities with skills and MCP servers.\" Claude by Anthropic, December 19, 2025.\n- Anthropic. \"Equipping agents for the real world with Agent Skills.\" Engineering at Anthropic, October 16, 2025.\n- Anthropic team (Theo Chu, David Soria Parra, Alex Albert). \"The Model Context Protocol (MCP).\" YouTube video, June 2025.\n- Barry Zhang and Mahesh Murag, Anthropic. \"Don't Build Agents, Build Skills Instead.\" YouTube video, December 8, 2025.\n- Cheney Zhang. \"Is MCP Dead? What We Learned Building with MCP, CLI, and Agent Skills.\" Milvus Blog, April 1, 2026.\n- Jitpal Kocher. \"MCP vs Skills vs CLI: which one wastes the least context?\" Wire Blog, May 14, 2026.\n- Model Context Protocol official documentation. \"What is the Model Context Prot","offTopic":false},{"id":"42e1b2f1-d369-481e-8168-02652c9292c3","excerpt":"How Affiliate Managers Can Use Claude Cowork to Recruit More Affiliates, Drive More Sales, and Scale Their Programs — Affiliate marketing is becoming more competitive every year.\n\nBrands want more affiliate sales.\n\nAffiliate managers are expected to recruit more partners, improve activation rates, reactivate dormant af","url":"https://www.reddit.com/r/affiliatefinders1/comments/1uenyyd/how_affiliate_managers_can_use_claude_cowork_to/","role":"request","weight":0.8818429,"occurredAt":"2026-06-24T19:51:04.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"affiliatefinders1","intent":"problem_report","painScore":0.36,"sentiment":1,"confidence":0.6484139,"matchedPatterns":["manual_process"],"statement":"The affiliate managers who learn how to properly leverage AI are going to have a significant advantage over those who continue doing everything manually.","title":"How Affiliate Managers Can Use Claude Cowork to Recruit More Affiliates, Drive More Sales, and Scale Their Programs","body":"Affiliate marketing is becoming more competitive every year.\n\nBrands want more affiliate sales.\n\nAffiliate managers are expected to recruit more partners, improve activation rates, reactivate dormant affiliates, increase revenue, analyze performance, communicate with publishers, and report results to leadership.\n\nMost affiliate managers simply don't have enough hours in the day.\n\nThat's why I believe AI is becoming one of the most important competitive advantages in affiliate program management.\n\nOver the last several months, we've been using Claude Cowork extensively at [Experience Advertising](https://www.experienceadvertising.com) to help manage affiliate programs, recruit affiliates, identify partnership opportunities, analyze performance, create communications, and automate many of the repetitive tasks that traditionally consume an affiliate manager's time.\n\nThe affiliate managers who learn how to properly leverage AI are going to have a significant advantage over those who continue doing everything manually.\n\n# Use AI to Recruit More Affiliates Faster\n\nAffiliate recruitment remains one of the highest ROI activities in affiliate marketing.\n\nThe challenge is finding quality affiliates that can actually drive sales.\n\nAffiliate managers need to identify:\n\n* Affiliate bloggers\n* Review websites\n* Influencers\n* Newsletter publishers\n* YouTube creators\n* Media websites\n* Content publishers\n* Industry experts\n\nThis is where Claude Cowork and [AffiliateFinders.com](https://www.affiliatefinders.com) become incredibly powerful together.\n\n[AffiliateFinders.com](http://AffiliateFinders.com) helps affiliate managers discover thousands of affiliate recruitment opportunities across virtually every niche and industry.\n\nInstead of spending hours searching Google, affiliate networks, social media platforms, and industry websites, affiliate managers can quickly identify high-quality affiliate prospects and then use Claude Cowork to research, prioritize, and personalize outreach efforts.\n\n# Try This in Claude Cowork\n\n\"Using [AffiliateFinders.com](http://AffiliateFinders.com), identify 25 affiliate recruitment opportunities in the B2B SaaS industry. Research each website, identify the best contact, summarize their audience, and create a personalized affiliate recruitment email.\"\n\n# Improve Affiliate Activation Rates\n\nOne of the biggest problems in affiliate marketing isn't affiliate recruitment.\n\nIt's affiliate activation.\n\nMany affiliates get approved but never generate a single click or sale.\n\nClaude Cowork can help create onboarding systems that educate affiliates, provide resources, and encourage them to start promoting immediately.\n\n# Try This in Claude Cowork\n\n\"Create a complete affiliate onboarding sequence including welcome emails, getting started instructions, top converting offers, promotional ideas, content suggestions, and follow-up emails for affiliates who have not generated clicks within 14 days.\"\n\n# Reactivate Dormant Affiliates\n\nMost affiliate programs are sitting on untapped revenue.\n\nMany affiliates who once generated sales simply stopped promoting.\n\nInstead of focusing exclusively on recruiting new affiliates, smart affiliate managers regularly re-engage previous producers.\n\nClaude Cowork can help identify dormant affiliates, analyze historical performance, and create personalized reactivation campaigns.\n\n# Try This in Claude Cowork\n\n\"Analyze this affiliate performance report and identify affiliates whose sales have declined by more than 40% over the past six months. Rank them by historical revenue and create personalized reactivation emails for the top opportunities.\"\n\n# Analyze Affiliate Performance More Effectively\n\nMost affiliate managers have plenty of data.\n\nThe problem is extracting actionable insights.\n\nClaude Cowork can help analyze reports from:\n\n* Impact\n* CJ\n* Awin\n* ShareASale\n* PartnerStack\n* Everflow\n* Refersion\n* TUNE\n\nInstead of manually reviewing spreadsheets, affiliate managers can quickly identify trends, opportunities, and problems.\n\n# Try This in Claude Cowork\n\n\"Analyze this affiliate network export and identify the top-performing affiliates by revenue, EPC, conversion rate, growth rate, and incremental value. Highlight the biggest growth opportunities.\"\n\n# Create Better Affiliate Communications\n\nAffiliate newsletters remain one of the easiest ways to increase affiliate engagement and drive additional sales.\n\nUnfortunately, many affiliate programs communicate inconsistently.\n\nClaude Cowork can help create:\n\n* Affiliate newsletters\n* Product launch announcements\n* Promotional updates\n* Seasonal campaigns\n* Contest announcements\n* Recruitment emails\n\n# Try This in Claude Cowork\n\n\"Create this month's affiliate newsletter featuring our top converting products, new promotions, seasonal opportunities, and recommendations affiliates can use to increase sales.\"\n\n# Build Better Affiliate Marketing Calendars\n\nSuccessful affiliate programs don't simply react.\n\nThey plan ahead.\n\nClaude Cowork can help create promotional calendars based on:\n\n* Holidays\n* Seasonal buying trends\n* Product launches\n* Industry events\n* Promotional opportunities\n* Content opportunities\n\n# Try This in Claude Cowork\n\n\"Create a 12-month affiliate marketing calendar for our ecommerce brand. Include major promotional opportunities, seasonal campaigns, affiliate communication schedules, and content recommendations.\"\n\n# Discover New Affiliate Partnership Opportunities\n\nOne of my favorite uses for Claude Cowork is partnership discovery.\n\nCombined with [AffiliateFinders.com](http://AffiliateFinders.com), affiliate managers can uncover partnership opportunities that competitors may never find.\n\nPotential partners include:\n\n* Bloggers\n* Influencers\n* Review websites\n* Newsletter publishers\n* YouTube creators\n* Podcast hosts\n* Industry media sites\n\n# Try This in Claude Cowork\n\n\"Using [AffiliateFinders.com](http://AffiliateFinders.com), identify 50 partnership opportunities for our ecommerce brand. Prioritize publishers with audiences that closely match our ideal customer profile.\"\n\n# Monitor Competing Affiliate Programs\n\nUnderstanding what competing affiliate programs are doing can provide valuable insights.\n\nClaude Cowork can help research:\n\n* Affiliate commission rates\n* Cookie durations\n* Recruitment strategies\n* Promotional tactics\n* Publisher relationships\n* Competitive positioning\n\n# Try This in Claude Cowork\n\n\"Research our top three competitors and compare affiliate commissions, cookie windows, publisher relationships, promotional strategies, and affiliate recruitment efforts. Identify areas where our program can improve.\"\n\n# Automate Affiliate Reporting\n\nAffiliate managers spend countless hours creating reports.\n\nClaude Cowork can dramatically reduce reporting time by helping create:\n\n* Weekly affiliate reports\n* Monthly performance reports\n* Executive summaries\n* Recruitment reports\n* Affiliate performance reviews\n\n# Try This in Claude Cowork\n\n\"Create an executive summary from this month's affiliate marketing report. Include affiliate sales growth, recruitment progress, top-performing affiliates, challenges, opportunities, and recommended next steps.\"\n\n# Why Affiliate Managers Should Be Paying Attention to MCP\n\nOne of the developments I'm most excited about is the upcoming launch of MCP support within Claude Cowork.\n\nMCP (Model Context Protocol) will allow Claude to connect with more platforms, tools, databases, reports, and business systems than ever before.\n\nImagine Claude having access to:\n\n* Affiliate network data\n* CRM systems\n* Analytics platforms\n* Email marketing platforms\n* Internal documents\n* Recruitment databases\n* Spreadsheets\n* Sales data\n\nAll at the same time.\n\nThe possibilities for affiliate managers are enormous.\n\n# Try This in Claude Cowork\n\n\"Using connected systems through MCP, analyze affiliate performance, CRM data, website analytics, customer acquisition costs, and email engagement data to identify our highest-value affiliate partnerships and revenue growth opportunities.\"\n\n# Want to Learn How to Actually Use Claude Cowork?\n\nMost affiliate managers are still using AI like a search engine.\n\nThe real opportunity comes from learning how to use:\n\n* Projects\n* Agents\n* Connectors\n* Skills\n* Automations\n* Scheduled Tasks\n* MCP\n* Team Collaboration\n\nThat's where the biggest productivity gains happen.\n\nIf you want to learn how to truly leverage Claude Cowork for affiliate marketing, affiliate recruitment, content creation, competitive research, reporting, and business growth, visit [LearnCowork.net](https://www.learncowork.net).\n\nI've been helping companies and marketing teams learn how to use Claude Cowork to become dramatically more productive and effective.\n\nThe difference between casually using AI and building AI-powered systems is massive.\n\n# The Future of Affiliate Program Management\n\nThe best affiliate managers have always been great relationship builders.\n\nNow they also need to become great at leveraging AI.\n\nClaude Cowork isn't replacing affiliate managers.\n\nIt's helping them recruit more affiliates, activate more partners, uncover more opportunities, communicate more effectively, analyze performance faster, and ultimately generate more affiliate revenue.\n\nAt [Experience Advertising](https://www.experienceadvertising.com), we've been helping brands grow affiliate programs for more than 19 years. We've recruited thousands of affiliates, managed programs across virtually every industry, and helped generate millions in affiliate-driven sales.\n\nAs AI continues to reshape affiliate marketing, we're incredibly excited about what's ahead.\n\nThe affiliate managers who embrace these tools today will have a significant advantage tomorrow.\n\n# About Experience Advertising\n\n[Experience Advertising](https://www.experienceadvertising.com) is a leading affiliate management agency and digital marketing consultancy specializing in affiliate program management, affiliate recruitment, influencer marketing, paid media, ecommerce marketing, and partnership growth. For more than 19 years, we've helped brands scale affiliate sales, recruit quality affiliates, and grow revenue through performance marketing partnerships.","offTopic":true},{"id":"dc092eec-6e21-48b6-b293-34f0de174777","excerpt":"Supercharging Software Development with Claude Code Plugins: The Complete Developer’s Guide to Anthropic’s Extensible AI Coding Assistant — Claude, the family of large language models developed by Anthropic, has evolved far beyond a conversational chatbot. In the hands of software engineers, product managers working cl","url":"https://www.reddit.com/r/AgentContext_dev/comments/1vtem7i/supercharging_software_development_with_claude/","role":"request","weight":0.85515475,"occurredAt":"2026-08-20T09:30:48.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"AgentContext_dev","intent":"problem_report","painScore":0.36,"sentiment":0.5,"confidence":0.62879026,"matchedPatterns":["manual_process"],"statement":"Instead of the user manually copying information back and forth, Claude can query a live system, read results, and act on them.","title":"Supercharging Software Development with Claude Code Plugins: The Complete Developer’s Guide to Anthropic’s Extensible AI Coding Assistant","body":"Claude, the family of large language models developed by Anthropic, has evolved far beyond a conversational chatbot. In the hands of software engineers, product managers working closely with engineering teams, DevOps specialists, and technical founders, it has become an active collaborator capable of reading codebases, editing files, running tests, managing git workflows, and integrating with external systems. At the center of this transformation sits Claude Code-Anthropic’s agentic coding tool-and the plugin system that turns a powerful general-purpose assistant into a specialized, team-aligned development environment.\n\nThis article examines Claude plugins in depth, with a primary focus on software development and adjacent technical fields. Drawing from Anthropic’s official documentation, GitHub repositories, product announcements, community analyses, and tutorial content including YouTube walkthroughs, it explores what plugins are, how they work, how developers install and create them, the most useful ones available today, and practical ways they reshape coding, testing, security, documentation, and collaboration workflows.\n\n### Understanding Claude Code as the Foundation\n\nClaude Code is Anthropic’s agentic coding assistant. It lives primarily in the terminal but also integrates with IDEs such as VS Code, Cursor, and JetBrains products, a desktop application, and even web and GitHub surfaces via the `@claude` tag. Unlike a simple chat interface that requires constant pasting of code snippets, Claude Code understands an entire project directory. It can plan multi-file changes, execute shell commands, create commits and pull requests, resolve merge conflicts, update dependencies, write tests, and explain complex legacy code-all through natural language.\n\nKey to its power is the Model Context Protocol, or MCP, an open standard Anthropic helped champion. MCP allows Claude to connect securely to external tools, databases, issue trackers, design systems, monitoring dashboards, and APIs. Instead of the user manually copying information back and forth, Claude can query a live system, read results, and act on them. Plugins package these connections, along with specialized instructions and behaviors, into reusable, shareable units.\n\nWithout plugins, developers still gain substantial productivity from Claude Code’s core capabilities and project-level instructions stored in `CLAUDE.md` files. Plugins, however, raise the ceiling dramatically. They standardize best practices across a team, reduce the need to re-explain workflows in every session, and enable Claude to operate with domain-specific expertise that would otherwise consume precious context window space or require repetitive prompting.\n\n### The Birth and Evolution of the Plugin System\n\nAnthropic introduced plugins for Claude Code in a public beta announcement on October 9, 2025. The company described them as a lightweight way to package and share any combination of slash commands (custom shortcuts), subagents (specialized agents for particular tasks), MCP servers (external tool connections), and hooks (code that runs at defined points in Claude’s workflow). The goal was to make customization portable and to reduce the complexity that arises when every developer maintains their own sprawling collection of local configuration files.\n\nPrior to plugins, customizations lived mainly in a project’s `.claude` directory or in personal settings. These approaches worked for individuals but made consistent team environments difficult. Plugins solved the distribution problem. A single install command brings in a coherent set of capabilities that can be enabled or disabled as needed, controlling how much additional context is injected into the system prompt.\n\nIn early 2026 Anthropic expanded the ecosystem further with knowledge-work plugins originally aimed at Claude Cowork (the broader productivity surface) but also usable inside Claude Code. These included specialized bundles for product management, engineering workflows, data analysis, and more. Simultaneously the official marketplace grew to include language-server plugins, security reviewers, browser automation tools, and design-to-code converters. By mid-2026, Anthropic’s official directory and community marketplace contained dozens of useful options. The official directory includes both Anthropic-maintained plugins and selected third-party integrations, while community submissions undergo validation, automated safety screening, and review before appearing in the public catalog.\n\nThe system continues to evolve. Plugins can now incorporate LSP (Language Server Protocol) servers for real-time code intelligence, background monitors that stream log output or other signals to Claude, and default settings that activate particular agents when a plugin loads. Marketplaces themselves have become first-class citizens: organizations can host private ones for internal tools, while public ones allow open-source maintainers and independent developers to distribute their work.\n\n### Anatomy of a Claude Plugin\n\nA Claude Code plugin is essentially a self-contained directory (or archive) that follows a conventional structure. At its heart usually sits an optional but recommended manifest file located at `.claude-plugin/plugin.json`. This JSON file declares the plugin’s name (an immutable slug used for namespacing), description, version, author, and other metadata. The name becomes a prefix for skills so that `/plugin-name:skill-name` avoids collisions with other plugins or core commands.\n\nClaude Code can load some local plugins without a manifest when their components use standard locations, but marketplace-distributed plugins normally include one to define their identity and metadata.\n\nAround the manifest developers place optional component directories at the plugin root:\n\nSkills live in a `skills/` folder. Each skill is typically a subdirectory containing a `SKILL.md` Markdown file with YAML frontmatter. The description field tells Claude when the skill is relevant; the body contains the detailed instructions Claude should follow when the skill is invoked. Skills can accept arguments via a `$ARGUMENTS` placeholder and can be restricted so the model does not invoke them automatically.\n\nAgents reside in an `agents/` directory. These are specialized sub-agents that Claude can hand work to for focused tasks such as security review, documentation generation, or multi-step refactoring.\n\nHooks are defined in `hooks/hooks.json`. They fire at specific lifecycle points-before or after tool use, on stop, on commit preparation, and so on-allowing a plugin to inject automatic checks, formatting, or notifications.\n\nMCP configuration appears in a `.mcp.json` file. This tells Claude Code which external MCP servers to start and how to connect to them. When a plugin installs, the associated servers become available automatically.\n\nLSP configuration lives in `.lsp.json` and points Claude at language servers such as `typescript-language-server`, `gopls`, `rust-analyzer`, or `pyright`. Once running, these servers supply diagnostics, go-to-definition, find-references, and other IDE-grade intelligence that Claude can use while editing.\n\nAdditional optional pieces include a `monitors/` directory for background processes whose stdout is streamed to Claude as notifications, a `bin/` folder whose executables are added to the Bash tool’s `PATH` while the plugin is active, and a `settings.json` that applies default configuration when the plugin is enabled.\n\nBecause everything is file-based-primarily Markdown and JSON-plugins remain easy to inspect, version-control, and audit. There is no compiled binary required for the core extension points, although MCP servers and LSP binaries may of course include their own native components.\n\n### Installing and Managing Plugins in Daily Practice\n\nClaude Code automatically registers the official Anthropic marketplace (`claude-plugins-official`) on first interactive launch. Users can also add community or private marketplaces with a simple command such as `/plugin marketplace add anthropics/claude-plugins-community` or `/plugin marketplace add their-org/internal-plugins`.\n\nOnce a marketplace is known, installation is equally straightforward. The interactive `/plugin` interface offers Discover, Installed, Marketplaces, and Errors tabs. From Discover a developer selects a plugin, chooses a scope (user-wide, project-wide via `.claude/settings.json`, local to the current repository, or managed by administrators), and confirms. Non-interactive installation is available via the claude plugin install CLI for scripting and CI.\n\nAfter installation a `/reload-plugins` command activates the new components without restarting the entire session. Plugins can be enabled, disabled, or uninstalled later; unused plugins that have not been exercised for several sessions appear in a “Not used recently” section so teams can prune context cost. Auto-update can be toggled per marketplace.\n\nTrust remains the user’s responsibility. Anthropic performs basic automated review on submissions and deeper review for the Verified badge, yet plugins may start external processes or load third-party code. Best practice is to examine the source repository linked from each marketplace listing before installing, especially in security-sensitive environments. Organizations can further restrict allowed marketplaces through managed settings.\n\n### High-Value Plugins for Software Development Workflows\n\nThe official and community ecosystems contain plugins that address nearly every stage of the software development life cycle. Several stand out for their practical impact.\n\nLanguage Server Protocol plugins form the foundation of accurate code intelligence. The `typescript-lsp` plugin, for example, brings full TypeScript and JavaScript language services into Claude’s environment. While Claude edits files it can receive real diagnostics, resolve imports, and navigate definitions without relying solely on its training data or approximate string matching. Similar plugins exist for Python (`pyright` or the official language server), Go (`gopls`), Rust (`rust-analyzer`), and many other languages. Installing the relevant LSP pack for a project’s primary languages measurably reduces the number of “does this even compile?” follow-up prompts.\n\nContext7, developed by Upstash and available through the official channels, injects live, version-specific documentation into Claude’s context. When a developer asks Claude to use a particular version of Next.js, React, or a rapidly evolving library, Context7 retrieves up-to-date, version-specific documentation and code examples rather than relying only on the model’s training data. This dramatically cuts hallucinations around API surfaces that change every few months.\n\nPlaywright provides browser automation and end-to-end testing capabilities. Once installed, Claude can launch a real browser, navigate pages, fill forms, click elements, take screenshots, and assert on results-all driven by natural language. Combined with Claude’s ability to write the underlying test code, this creates a tight loop for frontend and full-stack verification.\n\nThe `security-guidance` plugin, maintained by Anthropic, adds automatic pattern-based warnings on edits plus deeper LLM-powered review of diffs. It surfaces common vulnerability classes such as injection risks, XSS, SSRF, and hardcoded secrets before they reach a commit. Teams often pair it with external static-analysis MCP servers such as Semgrep for defense in depth.\n\nFrontend Design is an Anthropic-maintained plugin that steers Claude away from generic AI aesthetics. It supplies design-system skills, typography and color guidance, and component patterns so that generated UI code looks intentional and production-ready rather than template-like. When combined with a Figma MCP integration, the workflow becomes design-to-working-code with far less manual polishing.\n\nOth","offTopic":true},{"id":"f7eb890d-9197-4498-8d39-1fad5cb550e4","excerpt":"I made a CLI that catches crashes and lets Claude fix them on a throwaway branch — You wrap whatever command you already run:\n\n\n\nphantom npm run dev\n\n\n\nIt's invisible until your process exits non-zero. stdout, stderr, stdin stream through byte-for-byte and the exit code is preserved. On a crash it captures the stack tr","url":"https://www.reddit.com/r/ClaudeCode/comments/1vvjv9a/i_made_a_cli_that_catches_crashes_and_lets_claude/","role":"pain","weight":0.69104373,"occurredAt":"2026-08-22T18:25:01.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeCode","intent":"other","painScore":0.4,"sentiment":-1,"confidence":0.49360266,"matchedPatterns":[],"statement":"I made a CLI that catches crashes and lets Claude fix them on a throwaway branch.","title":"I made a CLI that catches crashes and lets Claude fix them on a throwaway branch","body":"You wrap whatever command you already run:\n\n\n\nphantom npm run dev\n\n\n\nIt's invisible until your process exits non-zero. stdout, stderr, stdin stream through byte-for-byte and the exit code is preserved. On a crash it captures the stack trace, the output tail and your git state, cuts a branch, and hands the whole thing to a headless Claude Code session that diagnoses the bug, writes a failing test, and patches it.\n\n\n\nThe part I actually care about: \\*\\*phantom re-runs your test command itself, outside the Claude session, and audits the branch against the starting commit after the session ends.\\*\\* Nothing in the report trusts the model's own word about whether it worked. If it says fixed, that's phantom's measurement.\n\n\n\nYou end up back on your own branch with a banner:\n\n\n\n╭────────────────────────────────────────────────────────────────────────╮\n\n│ 👻 phantom ✅ fixed · 1m 48s · 34.1k tokens (12k new · 22.1k cached)    │\n\n│ fix verified by phantom: tests pass and the command no longer crashes;  │\n\n│ your branch is unchanged                                                │\n\n│                                                                         │\n\n│ branch  phantom/fix-typeerror-cannot-read-properties-k3f9a              │\n\n│ review  git diff main..phantom/fix-typeerror-...                        │\n\n│ accept  git merge phantom/fix-typeerror-...                             │\n\n│ reject  git branch -D phantom/fix-typeerror-...                         │\n\n╰────────────────────────────────────────────────────────────────────────╯\n\n\n\nPlus a markdown post-mortem where the TL;DR comes from the session but every row in the verification table is measured by phantom.\n\n\n\n\\*\\*Safety, because this is an AI with write access to your repo\\*\\*\n\n\n\n\\- It never touches your branch. Everything happens on \\`phantom/fix-<slug>-<ts>\\`, cut from HEAD, and you're checked back out when it finishes — success, failure or Ctrl+C.\n\n\\- No pushes, no PRs, no network. \\`git push\\` is denied, there's no web tool, and there is no push code path. Not configurable.\n\n\\- \\`.env\\`, \\`\\*.pem\\`, \\`\\*.key\\`, \\`\\*\\*/secrets/\\*\\*\\` are enforced three times: permission deny rules, a \\`PreToolUse\\` guard hook that fails closed, and a post-session audit against the starting sha. Any hit discards the session's changes.\n\n\\- Dirty tree is refused outright. Hard caps on iterations and wall-clock.\n\n\\- Ctrl+C kills the process tree, rescues untracked files into a stash, resets the fix branch and puts you back.\n\n\n\n\\*\\*What it is not\\*\\*\n\n\n\nIt is not a sandbox. The session runs \\`node\\` — it has to, to run your tests — and \\`node -e\\` can in principle read anything your user can. The guard hook is \\*lexical\\*: it reads the text of a command, so it only refuses what a command says, not what it does. An audit in August found four ways past it in one afternoon. All four are fixed with regression tests, but the honest read is that a lexical guard is a speed bump and a fifth way probably exists. The real backstops are the ones that don't depend on parsing a command correctly: branch isolation, the post-session audit, and no pushes. Want hard isolation? Run it in a container.\n\n\n\nIt also declines crashes it can't work with — a non-zero exit with no error line, no stack trace, no file named and no test command gets refused rather than guessed at.\n\n\n\n\\*\\*Cost:\\*\\* recovery runs \\`claude -p\\` under your own account, so it bills your Claude subscription or API key like any other session. \\`PHANTOM\\_DISABLED=1\\` makes it a pure passthrough.\n\n\n\nZero runtime dependencies, MIT, Node >= 18, 532 tests, CI on macOS/Linux/Windows across Node 18–24.\n\n\n\nnpm install -g claude-phantom\n\n\n\nhttps://claudephantom.dev · https://github.com/waazy-w/claude-phantom\n\n\n\nHappy to be told why this is a bad idea — leave a star on github if you don't mind.","offTopic":true},{"id":"e8592108-4077-434a-8afb-d1f5cc5b5e10","excerpt":"Turn Claude Code sessions into a shareable graph your agent can query — Coding agents moved my bottleneck. Writing the code got fast. Understanding what Claude actually did became the slow part.\n\nThe evidence already exists. Every Claude Code session is sitting on your disk in `~/.claude/projects`: every tool call, eve","url":"https://www.reddit.com/r/ClaudeAI/comments/1vujjol/turn_claude_code_sessions_into_a_shareable_graph/","role":"pain","weight":0.6807489,"occurredAt":"2026-08-21T15:28:48.000Z","sourceKey":"reddit","sourceName":"Reddit","credibility":0.62,"venue":"ClaudeAI","intent":"other","painScore":0.35675675,"sentiment":-0.8918919,"confidence":0.5017472,"matchedPatterns":[],"statement":"Turn Claude Code sessions into a shareable graph your agent can query.","title":"Turn Claude Code sessions into a shareable graph your agent can query","body":"Coding agents moved my bottleneck. Writing the code got fast. Understanding what Claude actually did became the slow part.\n\nThe evidence already exists. Every Claude Code session is sitting on your disk in `~/.claude/projects`: every tool call, every error, every retry, every subagent it dispatched, every permission you denied. Almost nobody reads them, because a single session runs to thousands of lines of JSONL.\n\nSo I built rungraph. Free, MIT licensed, no paid tier.\n\n    npx rungraph\n    \n\nIt scans the transcripts already on your disk and opens an interactive graph of any session: your prompts run down the spine in time order, tool calls collapse into labelled nodes (`Bash · npm test ×12`, `Edit · canvas.jsx`), and subagents get their own lanes, so a fan-out of five reviewers reads as five lanes instead of interleaved noise. No hooks, no wrappers, no setup, so the run that went sideways yesterday is already there. Live sessions update on the graph while Claude works.\n\nThat part is table stakes. The two things below are why I still use it every day.\n\n# 1. The graph is something Claude can talk to\n\n    npx rungraph mcp --install\n    \n\nThat wires rungraph into Claude Code over MCP. Restart your session, and `npx rungraph mcp --check` prints exactly what to fix if it did not take. Now you stop scrolling transcripts and start asking questions in the terminal you already work in:\n\n* \"Which edits in my last run failed, and did any of them stay broken?\"\n* \"Did it actually run the tests, or just say it did?\"\n* \"What did the subagent I sent to audit auth actually find?\"\n* \"Where did the auth refactor first touch `token.js`?\"\n\nMy favourite part: **Claude answers in your terminal, and then the nodes behind that answer light up on the open graph.** It pans the canvas to them. If your dashboard is showing a different run, it follows the answer there, with one-click undo. If nothing is open, it opens a tab on the right run.\n\nThose are two ends of one loop, not two features. The terminal is where you ask, in your own session, with your own model, where you can read exactly what was said. There is deliberately no chatbot embedded in the dashboard and no headless `claude -p` hiding behind it, because that would mean hiding the conversation somewhere you cannot inspect. The canvas is where you see. You get a claim and the evidence for that claim at the same time, in the place each one belongs, so you are reviewing a run instead of trusting a summary about it.\n\nEvery highlight also produces a pastable link. Links name a focus by its *source* rather than by a frozen list of node ids, so a link and a fresh query can never disagree with each other: open one tomorrow, after the run has grown, and the query re-runs.\n\nClaude Code is what I built this for and what I use it on daily. But it is plain MCP over stdio and the graph underneath is a vendor-neutral IR, so rungraph also reads Codex CLI, Hermes Agent and opencode sessions in the same dashboard, with a chip rail to filter by agent. The tool names are identical everywhere (`list_runs`, `find_nodes`, `get_graph`, `get_detail`, `focus_nodes`, `get_current_view`, `open_visualization`), and so is the loop.\n\n# 2. Hand a run to someone else, and let their Claude read it\n\nAgent work is getting collaborative, and \"what did your agent do\" is currently answered by pasting a wall of terminal output into Slack.\n\nSelect the runs in the dashboard and hit export, or stay in the terminal:\n\n    rungraph export --last 2\n    \n\nEither way you get a single `.rungraph` file. Your teammate opens it in their own dashboard:\n\n    npx rungraph open <file>\n    \n\nThree things make this more useful than a transcript dump.\n\n**The bundle carries the intermediate representation, not raw transcripts.** So the viewer needs no adapters at all, and vendor neutrality survives the handoff: a Hermes or opencode run opens perfectly for someone who has only ever used Claude Code. Nobody has to install your agent to review your run.\n\n**Their Claude can query your run.** `rungraph mcp` aggregates across every live server, so a colleague's opened bundle sits alongside their own dashboard, and their Claude answers questions about your session with the same tools and the same highlighting. That is the collaborative version of the loop: you send a file, they ask their own agent what went wrong in it, and the nodes light up on their screen. Code review for agent runs, rather than for the diff the run happened to produce.\n\n**Signals are derived at view time, not baked in.** A bundle exported months ago gets today's calibrated flags when it is opened.\n\n# The export guard, and why it exists\n\nEvery export shows you an inventory of what is about to leave your machine, and **blocks outright when the secrets scan finds a high-confidence match.** You then choose your fidelity: redact each finding to a placeholder and keep the rest, strip all content down to just the shape (tool names, files, timings), or override the block when the finding is a false positive.\n\nThe dialog and the flags are the same code path with the same defaults, deliberately. Two consent surfaces teaching two different privacy postures would be worse than either one alone. Sharing a run should not be how you leak a key.\n\n# Flags worth your attention\n\nThe graph marks a tool that kept failing in one spot, an error the run never came back to fix, a step that burned far more tokens than everything around it, and the moments you denied a permission or interrupted a turn.\n\nCalibrating those against real Claude sessions was more interesting than I expected. Across 60 of my own sessions (1,081 nodes), no single tool node ever had more than **2** errors, so the obvious \"3 failures in a row\" rule literally never fires. And a real Claude retry spiral is not back-to-back Edits, it is `Edit` fails, `Read` the file, `Edit` fails again, so the detector has to walk each tool family's own subsequence within a lane. My first outlier thresholds sat almost exactly at the median, which meant \"outlier\" fired on half of all runs. Everything is deliberately conservative now, because a false alarm costs more than a missed one. Once you stop trusting the markers you are back to reading the whole run.\n\nThere is one flag that is not about what went wrong. An empty strip is a claim, and it is only worth something if rungraph actually read the run. These formats are undocumented and unversioned, so a vendor ships a release and your transcripts quietly change shape. Every run carries a coverage number for that reason, and the strip says `read 95% of this run` instead of showing you a reassuring blank space. Claude gets the same number over MCP, and is told to say it before calling a run clean.\n\nClick any node for the actual inputs, outputs, errors, and timing behind it.\n\n# Local by default\n\nThe server binds [`127.0.0.1`](http://127.0.0.1) only and makes zero outbound requests. Your transcripts never leave your machine, and nothing is shared until you run `export` yourself.\n\n# Built with Claude Code\n\nWorth saying out loud in this sub: the whole thing was built with Claude Code, across sessions rungraph can now read back. The demo GIF in the README is rungraph watching the live session that built the feature the GIF is demonstrating, which is the most direct answer I have to \"does this actually help\". The adapter layer is where it earned its keep, since the only honest way to parse an unversioned format is fixture-driven TDD against synthetic, format-faithful transcripts. Zero runtime dependencies, which is what keeps `npx rungraph` a single download.\n\n# Notes for format archaeologists\n\nThese formats churn more than you would guess. In Claude Code the tool that spawns a subagent is recorded as `Agent`, not `Task`, so anything keying on \"Task\" builds an empty lane tree. Denials arrive as `toolDenialKind: \"user-rejected\"`, and the automode variants that look identical are not a human saying no, which matters because a denied call recorded as an error otherwise reads as \"the last Edit failed and nothing came back to fix it\", a lie about a call you refused. Codex exit codes have lived in three shapes across exec generations. Forked sessions embed a re-stamped copy of the parent's history that has to be cut structurally rather than by timestamp. Hermes and opencode keep their delegation trees in SQLite, which needs Node 22.13+ for the built-in reader (older Nodes skip those two with a warning and everything else still works). My whole corpus parses clean across all four agents, but I want to see the rollout that breaks it. If you have one, send me the error.\n\n# Try it\n\n* Live demo: [https://fayzan123.github.io/rungraph](https://fayzan123.github.io/rungraph)\n* Repo: [https://github.com/fayzan123/rungraph](https://github.com/fayzan123/rungraph)\n\nRun `npx rungraph` against your own sessions, then `npx rungraph mcp --install` and ask Claude something you would previously have scrolled for. If it flags something real in a run you had already trusted, I want to hear about it.","offTopic":true}],"breakdown":[{"sourceKey":"reddit","sourceName":"Reddit","count":22}],"total":22}}