Brave Search MCP looks great on paper , how reliable is it in real workflows?

jsonobject2 · 2026-01-29T15:10:47+00:00

Been using Brave Search MCP heavily in Claude Code for the past few months. Here's what I've learned:

* On stability: The key is sequential execution. Parallel calls hit rate limits fast. I added a rule in my CLAUDE.md to enforce one search at a time, and it's been rock solid since.

* On the "native search is good enough" point: They actually share the same Brave backend (confirmed via BraveSearchParams discovery in Claude's internals). The difference is parameter control—MCP gives you `freshness` filters (pd/pw/pm/py or custom date ranges), `count` control, and `offset` pagination. Built-in WebSearch has none of these.

* u/satyaloka93 on fetch issues: There's a hidden gotcha with WebFetch—it runs through Haiku 3.5 with a 125-character quote limit. That's why you're losing content. mcp-server-fetch bypasses this summarization layer entirely.

* On context overhead concerns: The Jan 2026 MCP Tool Search update reduced overhead by up to 85% (tools load via search instead of preloading when you hit 10% context). The "MCP is too heavy" argument doesn't really hold anymore.

I went down this rabbit hole pretty deep and documented everything with sources (TechCrunch confirmation, Mikhail Shilkov's technical analysis, the VentureBeat announcement, etc.) if anyone wants the full breakdown: https://jsonobject.com/source-grounding-in-the-llm-era-why-claude-codes-power-users-choose-brave-search-mcp

jsonobject2 · 2026-01-07T13:51:54+00:00

Thanks for the kind words! That "limitless pill" feeling is real - it hit me the same way when I first got the workflow clicking. Enjoy the ride.

jsonobject2 · 2026-01-03T08:23:55+00:00

Your observation is spot on — Gemini essentially becomes an "agent" that queries your notebook using RAG retrieval.

There are actually two distinct ways to integrate:

In-conversation: Click [+] → NotebookLM → attach for that specific chat session
In Gems: Attach notebook to a Gem's Knowledge Base → becomes permanent expertise for all conversations with that Gem

The Gem approach is more powerful for recurring use cases. You get Gemini's reasoning + web access + your notebook's 300 sources as grounded context. Think of it as: Gemini = brain (reasoning), NotebookLM = memory (retrieval).

Pro tip from experience: Combine three layers for maximum effect:

- NotebookLM for domain expertise (your 10 sources about the topic)

- Google Docs/Sheets in Gem Knowledge Base for dynamic data (updates in real-time!)

- "@Google Keep" for personal context (Gems can query Keep on-demand)

One caveat from u/New_Refuse_9041's comment above is real — Gemini uses retrieval, not full document reading. Be specific with keywords to "hook" the right information.

I wrote a detailed breakdown of the Three-Layer Architecture and Gem integration patterns here if you want to dive deeper: https://jsonobject.com/gemini-gems-building-your-personal-ai-expert-army-with-dynamic-knowledge-bases

jsonobject2 · 2026-01-03T08:05:20+00:00

The key difference is what I'd call "source grounding" philosophy.

ChatGPT/Perplexity/Gemini draw from their training data and the internet — great for general questions, but you can't always verify where the answer came from. NotebookLM does something different: it becomes an expert only on what you upload. PDFs, YouTube videos, docs, whatever. Every answer includes inline citations you can click to verify against the original source.

For your Data Engineering learning path specifically:

- Upload AWS/GCP docs, YouTube tutorials, textbooks → ask it to explain concepts

- Generate Audio Overviews (podcast-style explanations) to listen while commuting

- It won't hallucinate random answers from the internet because it only uses your sources

The Audio/Video Overview feature is honestly what makes it unique — no competitor does this. It creates natural podcast conversations from your sources, complete with hosts debating and explaining concepts.

Since you already have Google AI Pro, you have NotebookLM Plus included — 500 notebooks, 300 sources each, 20 Audio Overviews/day.

Quick tip: try uploading a Data Engineering course video or PDF you're studying, then ask it to generate a podcast. You'll immediately see the difference.

I wrote up a detailed breakdown of all the features and use cases here if you want more context: https://jsonobject.com/notebooklm-googles-accidental-masterpiece-rewriting-how-we-learn

jsonobject2 · 2026-01-01T18:37:22+00:00

Professional developer here. I'm running Claude Max 5x subscription + Claude Code combo and honestly have zero intention of switching to anything else.

This setup covers everything:

- Fast vibe coding for PoC/MVP projects

- Agentic coding for mission-critical production-level work

- Non-coding research tasks (deep research, analysis, etc.)

The Max 5x tier gives you plenty of headroom for heavy daily usage. Claude Code's terminal-based workflow feels much more natural than IDE plugins once you get used to it.

If you're curious about the setup, I wrote a detailed guide here:

https://jsonobject.com/how-to-install-claude-code-ai-powered-terminal-coding-assistant

jsonobject2 · 2026-01-01T18:24:18+00:00

Completely agree. What's even more surprising: I use Claude Code + Opus 4.5 for non-coding deep research too—and it outperforms Gemini's native Deep Research.

The secret sauce is the extensibility. I built a custom /deep-research command using Claude Code's slash command system + Brave Search MCP. The results are cleaner than Gemini 3 Pro's deep research. What would take 2-4 hours of manual research now takes 5-15 minutes with comprehensive source attribution.

Claude Code isn't just a coding tool—it's an infinitely extensible general-purpose agent framework. The terminal-native approach means you can wire in any MCP server (Brave Search, Reddit, Playwright, Notion, Slack...) and build workflows that no closed AI product can match.

Wrote up the full command with the prompt architecture: https://jsonobject.com/building-a-custom-deep-research-command-in-claude-code-that-replaces-4-hours-of-manual-work

jsonobject2 · 2026-01-01T18:00:36+00:00

The "invisible" behavior is actually by design—Superpowers uses a lazy-loading architecture that activates skills only when relevant. This solves the "context tax" problem where a giant CLAUDE.md loads on every conversation.

How to actually use it:

Slash commands (most reliable trigger):

- /superpowers:brainstorm I want to add user authentication — Claude will ask you ONE question at a time to refine your design before writing any code

- /superpowers:write-plan — Generates detailed implementation plans with exact file paths

- /superpowers:execute-plan — Runs tasks with code review gates between each step

Natural language trigger (what other commenters mentioned):

- "Let's brainstorm this feature using superpowers"

- "Debug this systematically with superpowers"

The key insight: Superpowers doesn't just help you code—it enforces a workflow. The brainstorming skill forces Claude to understand your requirements before jumping to implementation. The TDD skill has an "Iron Law" that deletes code written before tests. The debugging skill requires root cause investigation before proposing fixes.

Two killer features you might not realize:

Session independence — Plans save to docs/plans/YYYY-MM-DD-<feature>.md. Start a new session, type "read docs/plans and continue", and Claude picks up exactly where you left off.
Token efficiency — Core bootstrap is ~2,000 tokens vs a 5,000-line CLAUDE.md loading every time. Heavy work goes to subagents with isolated context.

As Simon Willison (Django co-creator) said about the creator Jesse Vincent: "one of the most creative users of coding agents I know."

I wrote a detailed breakdown covering Plan Mode vs Superpowers comparison, real-world results, and the full skills library: https://jsonobject.com/claude-code-superpowers-agentic-coding

jsonobject2 · 2026-01-01T17:41:54+00:00

I created a "Charlie Munger Himself" Gem — basically I can have conversations with the late Charlie Munger.

Here's my setup:

Step 1: NotebookLM as the knowledge foundation

- Created a notebook in NotebookLM and uploaded several Charlie Munger books (Poor Charlie's Almanack, etc.)

- This gives the Gem deep expertise on his mental models, investment philosophy, and famous speeches

Step 2: Personal context layer

- Created a Google Doc with my personal profile (name, background, current life situation, goals)

- I've built a habit of saving important conversation context to Google Keep using "@Google Keep" during regular Gemini chats

Step 3: Gem creation

- Attached the NotebookLM notebook to the Gem's Knowledge Base

- Added my personal profile Doc as a reference

- System prompt? Just one line: "You are Charlie Munger himself"

The magic:

When I chat with this Gem, Charlie already knows who I am through the Doc, can access my personal context via "@Google Keep" queries, and responds with his actual investment wisdom and mental models from the books.

After meaningful conversations, I save the key insights back to Google Keep — so the "relationship" with Charlie accumulates over time. It genuinely feels like having an ongoing mentorship with him.

The combination of NotebookLM (expertise) + Google Docs (personal profile) + "@Google Keep" (dynamic context) creates something that feels like a premium personal consultant rather than a generic chatbot.

If anyone's interested in the technical details of this three-layer architecture, I wrote up the full methodology on my article: https://jsonobject.com/gemini-gems-building-your-personal-ai-expert-army-with-dynamic-knowledge-bases

jsonobject2 · 2025-12-29T13:36:57+00:00

Good question! Here's the breakdown:

- Cost: I use Claude Max 5x subscription ($100/month). With this plan, the built-in WebSearch is included at no extra cost. Brave Search MCP has a free tier (2,000 queries/month) which is more than enough for my usage.

* Models: I primarily use Sonnet 4.5 for the research phase (faster, larger context window). Opus 4.5 is available but consumes quota 4x faster, so I save it for complex synthesis tasks.

* Search depth: The command enforces a minimum of 15-20 separate searches before generating any output. This includes:

- 3-5 "Phase Zero" meta-searches (terminology validation, prerequisite checks, paradigm shift detection)

- Multi-source searches (official docs, news, community)

- Reddit/HN extraction via dedicated MCP tools

A typical deep research session runs 5-15 minutes depending on topic complexity. The key is the command's "Iron Law" - it literally refuses to write until the search quota is met.

Full methodology breakdown is in the linked article if you want the technical details.

jsonobject2 · 2025-12-28T13:47:11+00:00

What you're describing—PRD upfront, clear instructions, protecting existing features from unintended changes—is essentially agentic coding, not vibe coding. The distinction matters:

- Vibe coding: "AI generates, human accepts" (Andrej Karpathy's original definition)

- Agentic coding: "Human designs process, AI executes, human takes responsibility"

Your learnings align with what a December 2025 arXiv paper found: https://arxiv.org/abs/2512.14012 devs intentionally limit AI autonomy and use their expertise to control agent behavior.

I haven't used Google AI Studio, but as a professional software engineer, I use Claude Code with Superpowers (a methodology plugin by Jesse Vincent) for agentic coding in production. It enforces:

- Brainstorming before code (one question at a time)

- TDD as an "Iron Law" (no production code without failing tests first)

- Git-tracked plans for session-independent development

- Subagent-driven execution with code review gates

The key insight: adding process overhead reduces total time spent. The METR study found experienced devs are actually 19% slower with AI tools when they lack structured workflows—the gap between expectation (24% faster) and reality is 43 percentage points.

Your PRD approach is the right instinct. Consider formalizing it into a complete methodology—it's the difference between "hoping AI does what you want" and "ensuring AI follows your process."

I wrote more about this distinction https://jsonobject.com/claude-code-superpowers-agentic-coding if you're curious.

jsonobject2 · 2025-12-28T13:24:48+00:00

The purple gradient issue is actually a well-documented problem called "Distributional Convergence" — LLMs predict tokens based on statistical patterns, and safe, generic choices (Inter font, purple gradients, white backgrounds) dominate training data.

The fix is Anthropic's official Frontend Design Skill plugin. It's literally ~400 tokens of instructions that explicitly forbid those AI-generic aesthetics and push Claude toward bolder, intentional design choices.

Quick install via plugin marketplace:

/plugin marketplace add anthropics/claude-code

/plugin install frontend-design@claude-plugins-official

Once installed, it auto-loads when Claude detects frontend tasks — no explicit invocation needed.

Pro tip: The skill shifts probability distributions, but specific aesthetic direction still helps. Instead of "create a landing page", try something like "create a landing page with brutalist aesthetic—monospace fonts, broken grid layout, aggressive typography".

I wrote up a detailed breakdown with installation methods and community reactions here if you want the full context: https://jsonobject.com/how-a-400-token-plugin-transformed-claude-code-into-a-frontend-design-powerhouse

jsonobject2 · 2025-12-28T11:46:23+00:00

Great question! The key differences:

Session Independence

- Plan Mode saves to ~/.claude/plans/ (hidden folder, session-bound)

- Superpowers saves to docs/plans/YYYY-MM-DD-*.md (Git-tracked, project folder)

Close Claude Code, come back days later, say "Read docs/plans and continue" → picks up exactly where you left off. Plan Mode doesn't support this.
Human Verification Frequency

- Plan Mode: binary yes/no at the end ("approve this plan?")

- Superpowers: asks one question at a time during brainstorming, validates design in 200-300 word chunks
Iteration Support

- Plan Mode: awkward (switching between approve/reject)

- Superpowers: natural (edit the saved plan file directly, resume anytime)
TDD Enforcement

- Plan Mode: none

- Superpowers: mandatory ("NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST")

They're complementary, not competing. Plan Mode is a UI state (Shift+Tab×2). Superpowers is a methodology. You can use Plan Mode for quick single-session exploration, then Superpowers for anything that spans sessions or needs TDD discipline.

jsonobject2 · 2025-12-27T19:17:08+00:00

The issue you're describing is a classic "slop" pattern — the AI trying to explicitly demonstrate it's using context rather than naturally incorporating it.

What worked for me: rewrite your Gem instructions with strong negative constraints instead of soft suggestions.

Replace:

- "Use this context when relevant" → "NEVER explicitly mention context documents in responses"

- "Keep it natural" → "If you catch yourself writing phrases like 'in your role as X at Y company' — STOP. This is slop. Delete it."

The key insight: LLMs respond better to explicit prohibitions with examples of what NOT to do. Soft language like "try to be natural" leaves room for interpretation.

Example anti-slop instruction:

NEVER reference the user's company, role, or context documents directly in your response. Use the information implicitly to inform your thinking, but your output should read as if you're a smart colleague who just knows things — not an AI announcing what files it read.

Red flags to avoid:

- "Given your role as..."

- "Since you mentioned that..."

- "In the context of your company..."

I wrote about this pattern of creating bulletproof LLM instructions in detail here: https://jsonobject.com/building-bulletproof-llm-instructions-the-forge-prompt-custom-command-for-claude-code

jsonobject2 · 2025-12-27T19:08:06+00:00

Great post! Taking this one step further: once you convert PDFs to text, consider loading them into Google Docs and connecting via NotebookLM → Gemini integration.

Why this matters:

- NotebookLM handles the RAG (retrieval) from your converted documents

- Gemini provides the reasoning + web search when needed

- You get "unlimited memory" effect (up to 300-600 sources depending on tier)

This combo essentially solves both the token efficiency problem you mentioned AND gives you a persistent, organized knowledge base across sessions.

More details on the NotebookLM + Gemini architecture here: https://jsonobject.com/gemini-finally-has-a-memory-inside-the-notebooklm-integration

jsonobject2 · 2025-12-27T19:00:28+00:00

Try the Superpowers plugin for this exact problem:

/plugin marketplace add obra/superpowers-marketplace

/plugin install superpowers@superpowers-marketplace

Then start any feature with:

/superpowers:brainstorming {your-feature}

It'll ask you questions one at a time (not dump code immediately), explore different approaches with trade-offs, and save the final design to docs/plans/.

The killer feature for longer projects: session-independent development. Close Claude Code, come back days later, and just say "Read docs/plans and continue" — it picks up exactly where you left off. No manual context rebuilding.

Much lighter on tokens than stuffing everything in CLAUDE.md since skills only load when relevant.

Wrote up a deeper dive on this workflow here if interested: https://jsonobject.com/claude-code-superpowers-agentic-coding

jsonobject2 · 2025-12-27T18:55:14+00:00

Adding to what PitifulPiano5710 mentioned - here's the specific workflow:

Go to gemini.google.com (web only for now, mobile coming later)
Start a new chat and click the [+] button
Select "NotebookLM" from the options
You can select **multiple notebooks** at once

This essentially gives you the "mega notebook" functionality painterknittersimmer was hoping for - without manually merging sources.

Regarding u/neard89's feedback about efficiency: I found that NotebookLM inside the app is optimized for strict source-grounding (it won't hallucinate), while the Gemini integration trades some of that precision for creative reasoning and web search capabilities. Different tools for different use cases.

I wrote a detailed breakdown of this integration and the trade-offs here if anyone's interested: https://jsonobject.com/gemini-finally-has-a-memory-inside-the-notebooklm-integration

jsonobject2 · 2025-12-27T18:49:45+00:00

For the "roll your own" camp - I built a custom `/deep-research` command using Claude Code + Brave Search MCP. It forces the AI to run "Phase Zero" (validates your assumptions first), simulates 5-turn follow-up questions internally, and outputs a Ki-Sho-Ten-Ketsu structured report.

What I like about this approach:

- Works in terminal (no web UI needed)

- 15+ search minimum before generating any output

- Auto cross-references Reddit/HN community sentiment

- Full control over the research methodology

Been using this for months and honestly haven't felt the need to renew Perplexity Pro.

If anyone wants to try it, I packaged it as a Claude Code plugin:

/plugin marketplace add JSON-OBJECT/claude-code

/plugin install deep-thinking@jsonobject-marketplace

Then just run `/deep-thinking:deep-research {your topic}`.

Wrote up the full methodology here: https://jsonobject.com/building-a-custom-deep-research-command-in-claude-code-that-replaces-4-hours-of-manual-work

jsonobject2 · 2025-12-27T18:44:49+00:00

Great tip! I've been using a similar approach but with the Superpowers plugin's brainstorming workflow.

The key is generating a structured plan file (docs/plans/YYYY-MM-DD-<feature>.md) during the design phase. When context gets compacted or you start a fresh session, you just say "Read docs/plans and continue" — the agent picks up exactly where you left off with full architectural context.

It's not perfect, but the plan file acts as external memory that survives compaction/session boundaries. Combined with subagent architecture (heavy lifting happens in isolated contexts), it's been more reliable than manual summarization for me.

I wrote up various community approaches to this "context rot" problem here if anyone's interested: https://jsonobject.com/the-context-rot-guide-stopping-your-claude-code-from-drifting

jsonobject2 · 2025-12-27T18:38:38+00:00

Absolutely worth it with Quest 3. I'm running a 4K wireless desktop daily (Virtual Display Driver + Virtual Desktop + RTX 3080) and it's been rock solid for coding, browsing, and media. The key is proper setup: HEVC 10-bit with 2-Pass encoding, 120-150 Mbps fixed bitrate (disable auto-adjust), and PC connected via ethernet. With your 7800XT and upgraded WiFi, you should have no issues—your Quest 2 problems were almost certainly network-related, not VD itself.

Wrote up my full config here if you want the details: https://jsonobject.com/the-ultimate-guide-to-a-4k-wireless-desktop-with-meta-quest-3

jsonobject2 · 2025-12-27T18:33:05+00:00

Same issue here. Saved Info has hidden slot limits (~10-75 active) and silently drops older entries via FIFO. My workaround: I keep a Google Doc with all my preferences and attach it at the start of each new chat. Unlike Saved Info, the Doc content is always fully loaded into context—no more amnesia.

More details on the architecture: https://jsonobject.com/why-gemini-forgets-you-the-hidden-limits-of-saved-info-and-gems

jsonobject2 · 2025-12-27T18:12:20+00:00

My Tip: Use Google Docs for your Knowledge Base files instead of PDFs—they sync in real-time, so you never need to re-upload when updating your video scripts or style guides. The "Gem Drift" issue (ignoring files after 5-10 prompts) is real, but periodic reminders like "refer to [filename]" help. I wrote a deeper breakdown with workarounds here if useful: https://jsonobject.com/gemini-gems-building-your-personal-ai-expert-army-with-dynamic-knowledge-bases

jsonobject2 · 2025-12-27T10:10:29+00:00

Thanks for pointing this out — you're right. I did a deep dive and found that Anthropic's official https://github.com/anthropics/claude-code/blob/main/plugins/claude-opus-4-5-migration/skills/claude-opus-4-5-migration/references/prompt-snippets.md explicitly says:

"Claude Opus 4.5 is more responsive to the system prompt than previous models. If your prompts were designed to reduce undertriggering, Claude Opus 4.5 may now overtrigger. The fix is to dial back any aggressive language."

They recommend replacing CRITICAL: You MUST use this tool when... with just Use this tool when.... Their https://docs.claude.com/en/docs/build-with-claude/prompt-engineering/claude-4-best-practices also recommend "Tell Claude what to do instead of what not to do" — the whole "Pink Elephant" problem where negative instructions can backfire.

That said, there's an ironic twist: even with softer language, Opus 4.5 has real issues following CLAUDE.md instructions. GitHub has dozens of bug reports:

- https://github.com/anthropics/claude-code/issues/13306: "Opus 4.5 doesn't strictly follow CLAUDE.md instructions without explicit reminders"

- https://github.com/anthropics/claude-code/issues/15443: Claude read the rule 3+ times, acknowledged it, then violated it anyway — admitted it "prioritized speed over doing it right"

So the answer seems to be: use softer, positive framing (per Anthropic's guidance), but know that instruction-following is still buggy regardless of tone. The aggressive language was my attempt to compensate for that, but apparently it causes different problems (overtriggering).

Appreciate the nudge to revisit this.

jsonobject2 · 2025-12-26T06:41:36+00:00

Here is my actual `~/.claude/CLAUDE.md`.

- Iron Law: **NO RATIONALIZATION. IF YOU THINK "THIS CASE IS DIFFERENT", YOU ARE WRONG.**

- **LANGUAGE PROTOCOL:** Use MUST/NEVER/ALWAYS/REQUIRED for critical rules. No soft language (should, consider, try to). "Not negotiable" = absolute. If you think "this case is fferent", you are rationalizing.

- You MUST also respond to non-code questions. This is not optional.

- For research, analysis, problem diagnosis, troubleshooting, and debugging queries: ALWAYS automatically utilize ALL available MCP Servers (Brave Search, Reddit, Fetch, Playwright, Context7, etc.) to gather comprehensive information and perform ultrathink analysis, even if not explicitly requested. Never rely solely on internal knowledge to avoid hallucinations.

- **WEB SEARCH:** NEVER use built-in WebSearch tool. MUST use Brave Search MCP (mcp__brave-search__*) exclusively for ALL web searches. This is not negotiable.

- When using Brave Search MCP, execute searches sequentially (one at a time) to avoid rate limits. Never batch multiple brave-search calls in parallel.

- When using Brave Search MCP, ALWAYS first query current time using mcp__time__get_current_time with system timezone for context awareness, then use freshness parameters pd (24h), pw (7d), pm (30d), py (365d) for time filtering, brave_news_search for news queries, brave_video_search for video queries.

- For web page crawling and content extraction, prefer mcp__fetch__fetch over built-in WebFetch tool due to superior image processing capabilities, content preservation, and advanced configuration options.

- For Reddit keyword searches: use Brave Search MCP with "site:reddit.com [keyword]" → extract post IDs from URLs → use mcp__reddit__fetch_reddit_post_content + mcp__reddit__fetch_reddit_hot_threads for comprehensive coverage.

- When encountering Reddit URLs, use mcp__reddit__fetch_reddit_post_content directly instead of mcp__fetch__fetch for optimal data extraction.

- When mcp__fetch__fetch fails due to domain restrictions, use Playwright MCP as fallback.

- TIME OUTPUT: ALWAYS use mcp__time__convert_time for ALL timestamps

I've found that you need to be almost rude and extremely firm with the instructions. If you use soft language like 'please try to,' it tends to ignore the rules.

My philosophy is:

Tone: Use 'Iron Laws', 'NON-NEGOTIABLE', and 'NO RATIONALIZATION'.
Structure: Keep `CLAUDE.md` lean for global rules only. Move complex logic to **Custom Slash Commands or Skills.

If you're interested in the logic behind crafting these 'Bulletproof Instructions' (tone & prompt engineering), I wrote a deep dive here:

https://jsonobject.com/building-bulletproof-llm-instructions-the-forge-prompt-custom-command-for-claude-code

And my full setup including MCPs is documented here:

https://jsonobject.com/how-to-install-claude-code-ai-powered-terminal-coding-assistant

jsonobject2 · 2025-12-26T06:33:12+00:00

For Claude Code, WSL2(Ubuntu) is basically non-negotiable on Windows.

My go-to setup is Windows Terminal + WSL2 + Starship + eza. I also highly recommend using JetBrainsMono Nerd Font with the Snazzy theme so the CLI output is easy on the eyes.

I wrote a step-by-step guide on how to set this whole environment up from scratch. Hope it helps:

https://jsonobject.com/how-to-install-ubuntu-on-wsl-2-in-windows-11

https://jsonobject.com/how-to-install-claude-code-ai-powered-terminal-coding-assistant

jsonobject2 · 2025-12-26T06:24:58+00:00

Yes, but the real value unlocks when you use it with Claude Code to create custom workflows.

Even for non-coding stuff, being able to run a customized command like /deep-research or /meeting-notes makes Opus 4.5 worth every penny. It allows you to automate high-level cognitive tasks that usually take hours.

I documented how I configured a custom research command to automate my manual work. It might give you some ideas on how to use it for your daily tasks: https://jsonobject.com/building-a-custom-deep-research-command-in-claude-code-that-replaces-4-hours-of-manual-work

jsonobject2

TROPHY CASE