DEV Community

RelayRouter
RelayRouter

Posted on

Useful Plugins for Claude Fable 5.2: Tested Persistent Overhead, Usage Guide, and Pitfalls to Avoid

They are all called “plugins,” yet some add 0 tokens to every turn, while others add 1,567.

Those two figures come from Claude Code’s built-in claude plugin details command and refer to two plugins in the official repository. The gap may not look enormous, but it reveals something important: a plugin’s real bill is not shown on its listing page. It appears in every request you make afterward.

Claude Fable 5.2 was released on November 9, 2026. Its API model name is claude-fable-5-2, and it costs $8 per million input tokens and $40 per million output tokens. That is not cheap, so choosing which plugins to install is no longer merely a matter of taste. It also determines how much extra material each turn in a session has to read—and whether several subagents may quietly be launched behind the scenes.

One point needs to be clear up front: plugins belong to Claude Code, not to any particular model version. There is no plugin list curated specifically for Fable 5.2. This article approaches the question from the opposite direction: when the main session uses Fable 5.2, which plugins become more worthwhile because of the model’s pricing, behavior, and API rules?

We will proceed in this order: first, calculate the costs; next, use the official command to measure the persistent overhead of 13 plugins; then examine feature-dev, code-review, security-guidance, and hookify one by one; after that, look at language servers and two MCP plugins; move on to editor usage; and finally explain how to consolidate all client entry points. Every figure in this article includes its measurement environment. Versions change, and the numbers will change with them, so treat the output on your own machine as the final authority.

1. Start With the Bill: Where the Money Goes When You Add Plugins to Fable 5.2

From first principles, a plugin can do only three things: add a capability to the session (something it can see, look up, or click), add a constraint (review or blocking), or add a workflow (what happens first and what follows). Capabilities, constraints, and workflows all have a cost. Those costs also fall into only three categories.

First, persistent overhead. The official documentation states this plainly: once a plugin is enabled, the names and descriptions of its skills, agents, and commands enter the context on every turn, whether or not that turn uses them. Their full contents are loaded only when invoked.

Second, invocation overhead. When a skill or agent is actually triggered, its full content is loaded, and that cost is incurred each time. Subagents deserve particular attention. In the official explanation of Fable 5.2’s behavioral differences, Anthropic notes that the amount of delegation to subagents depends on your tools and task—and that subagents may account for a substantial share of a session’s total cost.

Third, side effects. Hooks are commands that run with your user permissions, MCP servers are persistent processes, and language servers require installed binaries. The official security documentation puts it bluntly: plugins can execute code with your user permissions. This cost is measured not in tokens, but in trust.

Now consider a few figures for Fable 5.2 itself. They determine the unit price of those three costs:

Item Value Source
Input / output $8 / $40 per million tokens Product page
Cache reads $0.20 per million tokens Product page
Fast mode $16 / $80, up to about 2.5× faster Product page
Context / maximum output 1M / 128K Platform documentation
Minimum Claude Code version v2.1.321 Changelog

Caching cushions persistent content. Take 1,567 tokens as an example: with a cache hit, each turn costs about 0.03 cents; without a hit, reading those tokens at the $8 input rate costs about 1.25 cents. Persistent overhead is therefore rarely the largest expense. Its main drawbacks are the context-window space it consumes and the one-time reread when the cache is invalidated.

The costs that truly deserve attention are invocation overhead and subagents. We will evaluate every plugin below against all three categories.

First, confirm that your Claude Code version supports Fable 5.2:

claude --version              # Requires 2.1.321 or later
claude --model fable          # Uses the alias; the full name is claude-fable-5-2
Enter fullscreen mode Exit fullscreen mode

You can also enter /model fable inside a session. One measured result is worth noting: in Claude Code 2.1.329, selecting claude-fable-5-2 produces a request body containing thinking: {"type": "adaptive"} and output_config.effort: "medium". In other words, Claude Code defaults to medium, while the official migration guide recommends starting with high. This will matter when we discuss hookify.

2. The Measured Numbers: Persistent Overhead for 13 Plugins

First, a sense of the marketplace’s scale. As of November 19, 2026 (official repository commit d7d3279), the official marketplace list, marketplace.json, contained 317 uniquely named entries. Of those, 55 had their source code in the official repository—41 under plugins/ and 14 under external_plugins/. The remaining 262 pointed to external repositories or installation commands. The official documentation also notes that most entries in this directory come from partners and other authors; only a small subset is maintained directly by Anthropic.

Installing all 317 is not an option. Measure before you choose. There is only one command. If the plugin is already installed, use its name directly:

claude plugin details feature-dev
Enter fullscreen mode Exit fullscreen mode

If it is not installed and you only want to inspect it first, clone the official repository (anthropics/claude-plugins-official; set the OFFICIAL_REPO environment variable to the repository’s clone URL), load it with --plugin-dir, and then measure it:

git clone --depth 1 "$OFFICIAL_REPO" claude-plugins-official
claude --plugin-dir ./claude-plugins-official/plugins/feature-dev plugin details feature-dev
Enter fullscreen mode Exit fullscreen mode

Here are the measured results for 13 plugins (Claude Code 2.1.329; figures are estimates reported by the official command, in tokens):

Plugin Components Persistent overhead
security-guidance 4 hook categories ~0
typescript-lsp 1 language server ~0
context7 1 remote MCP server ~0
playwright 1 MCP server ~0
code-review 1 command ~22
code-simplifier 1 agent ~66
frontend-design 1 skill ~80
commit-commands 3 commands ~105
claude-code-setup 1 skill ~141
claude-md-management 2 skills ~177
feature-dev 1 command, 3 agents ~240
hookify 5 skills, 1 agent, 4 hook categories ~294
pr-review-toolkit 1 skill, 6 agents ~1,567

Keep two points in mind when reading this table.

First, hooks, language servers, and MCP servers all show 0 in this column because the command counts only the names and descriptions of skills, agents, and commands. That does not mean they are free. MCP tool definitions are resolved at runtime and, as the command output explicitly says, are “not included.” Hooks run commands on your machine, so their cost is trust rather than tokens.

Second, agent descriptions are what create the largest differences. The six agents in pr-review-toolkit add about 1,567 tokens in total, and code-simplifier alone accounts for roughly 710 of them. If all you want is code simplification, installing code-simplifier by itself is enough; there is no need to bring in the whole toolkit.

There is also good news about caching. The official caching documentation says that enabling or disabling plugin skills, commands, agents, or hooks does not invalidate Claude Code’s cache; their content is simply appended after the existing conversation. Plugins with MCP servers follow the MCP rules instead: tool definitions are lazily loaded by default, and connecting a new service midway through a session does not disrupt the already cached portion.

That gives us a clear plugin-selection order: start with plugins that add a needed capability or constraint, then examine their persistent overhead, and finally check whether they launch additional subagents.

3. feature-dev: Break Large Features Into Seven Stages

feature-dev consists of one command and three agents in the official repository, with persistent overhead of about 240 tokens. The command is /feature-dev, and you can append the requirement directly:

/feature-dev Add department filtering to the admin export feature
Enter fullscreen mode Exit fullscreen mode

Reading the command file shows that it divides feature development into seven stages:

  1. Discovery: establish the problem and constraints first, summarize them, and ask you to confirm.
  2. Codebase exploration: launch 2 to 3 code-explorer agents in parallel to map similar features and the architecture, read the key files, and then consolidate the findings.
  3. Clarifying questions: turn edge cases, error handling, and compatibility concerns into explicit questions, then wait for your answers before proceeding.
  4. Architecture design: have 2 to 3 code-architect agents propose three alternatives—a minimal change, a clean architecture, and a pragmatic balance—compare them, and ask you to choose.
  5. Implementation: make changes only after receiving explicit approval.
  6. Quality review: launch 3 code-reviewer agents in parallel to examine simplicity and duplication, defects and correctness, and conventions and abstractions.
  7. Summary: explain what was done, which files changed, and what should happen next.

Why is it a good match for Fable 5.2? Because Anthropic documents one behavior of Fable 5.2: on long, multi-step tasks, it may sometimes end a turn by “listing remaining items” or “asking whether to continue,” especially at the low and medium effort levels. As measured earlier, Claude Code defaults to medium. Stages 3 and 4 of feature-dev force the process to pause and wait for your confirmation. In effect, the workflow hard-codes “ask when you should ask” instead of relying on the model’s own judgment.

What does it cost? All three agent definition files specify model: sonnet. According to the official subagent documentation, a subagent’s model is selected in this priority order: a parameter supplied for the individual invocation, the model field in the definition, the CLAUDE_CODE_SUBAGENT_MODEL environment variable, and only then the main session’s model. That means feature-dev’s exploration, design, and review agents do not follow the main session onto Fable 5.2; they resolve through the sonnet alias instead. Keeping the main session for the parts that require judgment is a sensible division of labor.

The official documentation also states where it is not appropriate: one-line fixes, trivial changes, and small tasks whose solution is already clear. In those cases, launching several extra agents costs more than it delivers.

4. code-review: Use a Separate Context for Verification

code-review contains only one command and adds about 22 persistent tokens, putting it near the low end of these 13 plugins. It operates on a pull request:

/code-review            # Print results only in the terminal
/code-review --comment  # Post the results as a PR comment
Enter fullscreen mode Exit fullscreen mode

It requires the GitHub CLI, gh, to be installed and authenticated. By default, results appear only in the terminal; they are posted as a comment only when --comment is supplied. The command skips a PR if it is closed, still a draft, too trivial, or has already been reviewed.

One detail deserves to be documented: the plugin’s README does not match its command file. The README says that four agents review in parallel, with the fourth examining git blame and history, after which each issue receives a score from 0 to 100 and anything below 80 is filtered out. The command file in the November 19, 2026 commit actually runs a different workflow:

  1. A haiku agent first decides whether the PR should be reviewed.
  2. Another haiku agent identifies the paths of relevant CLAUDE.md files.
  3. A sonnet agent summarizes the changes.
  4. Four agents run in parallel: 2 sonnet agents check compliance with CLAUDE.md, while 2 Opus agents look for clear defects.
  5. For every issue reported by the latter agents, another subagent is launched to verify it—Opus for defect findings and sonnet for CLAUDE.md findings.
  6. Any issue that fails verification is discarded before output.

The command file no longer contains the scoring system or the 80-point threshold. The command file—not the README—is what executes, so if you want to change this behavior later, commands/code-review.md is the file to edit.

Why does this pair well with Fable 5.2? Because the value of review lies in changing the context. The code-writing session is already invested in its own approach; asking it to review itself makes it easy to follow the same assumptions. code-review’s reviewers start from the PR diff in a fresh context, and they primarily use Opus and sonnet rather than the main session’s Fable 5.2 pricing.

The tradeoff is equally clear: one complete review launches at least 7 agents—2 for prechecks, 1 for summarization, and 4 parallel reviewers. Every issue found also triggers an additional verification agent, so a large PR can launch many more. The official recommendation is to treat the results as a starting point for human review; urgent fixes are not a good fit for this workflow.

If you need a more granular breakdown, pr-review-toolkit provides six agents assigned to specific themes, including comments, tests, error handling, and type design. But as measured earlier, its persistent overhead is about 1,567 tokens. Its definition files reveal another important point: 2 of the 6 agents explicitly specify model: opus, while the other 4 use inherit. inherit means following the main session, so when the main session uses Fable 5.2, those four agents also run at Fable 5.2 pricing. Factor that in before installing it.

5. security-guidance: Almost Zero Persistent Overhead, With Costs at Turn End and Commit Time

security-guidance consists entirely of hooks, with no skills or agents, so its persistent overhead is 0. The official documentation describes it as automatic after installation, with no command to invoke. It checks code written by Claude at three points:

  • After every file edit: pattern matching checks for dangerous constructs such as eval(, pickle, .innerHTML =, or changes under .github/workflows/. It does not call Claude and consumes no model usage.
  • At the end of each turn: the git diff from that turn is sent to another Claude call for a security review. It runs in the background and does not delay the response. If it finds a problem, it instructs the main session to fix it in a later turn.
  • When Claude runs git commit or git push: a deeper review is launched. It reads surrounding code such as callers and filtering functions to reduce false positives.

The latter two incur model usage. The official documentation says both use Opus by default, and you can change that with environment variables: SECURITY_REVIEW_MODEL controls the end-of-turn review, while SG_AGENTIC_MODEL controls the commit review. Reading the source confirms this. When no override is set, it queries /v1/models on the current endpoint for a newer available Opus model, falling back to the hard-coded claude-opus-5-5 only if that lookup fails. This means that if you use a custom endpoint, you should confirm that it exposes that model name. This conclusion comes from reading the source; it was not tested against a live endpoint.

Several limits prevent runaway usage: it reviews at most 30 changed files per turn, triggers no more than 3 consecutive times, and performs no more than 20 commit reviews in any rolling one-hour window. To disable individual layers, use these environment variables:

Variable Effect
ENABLE_PATTERN_RULES=0 Disable pattern checks during editing
ENABLE_STOP_REVIEW=0 Disable end-of-turn reviews
ENABLE_COMMIT_REVIEW=0 Disable commit and push reviews
ENABLE_CODE_SECURITY_REVIEW=0 Disable all AI reviews at once
SECURITY_GUIDANCE_DISABLE=1 Disable the entire plugin without uninstalling it

Windows users should pay attention to the interpreter. Its hooks are launched by a detection script that skips the Microsoft Store placeholder python3 and tries python, then py -3. The official documentation requires Python 3.7 or later on PATH, while the “agentic mode” used for commit reviews requires 3.10 or later. On first run, it also creates a virtual environment under ~/.claude/security/ and needs network access to install dependencies. Without an available Python installation, these hooks do not work.

This is not a cure-all. The official documentation makes clear that none of these layers prevents a write or commit. It merely turns discovered issues into instructions for the code-writing session. Treat it as one layer in a defense-in-depth strategy.

6. hookify: Turn “Do Not Stop Early” Into a Rule

Of these plugins, hookify is particularly good at compensating for a Fable 5.2 behavioral weakness. As noted earlier, the official documentation says the model sometimes ends a turn early during long tasks, and this behavior is more common at low and medium. Claude Code defaults to medium. You can raise the setting with /effort high, or you can use hookify to enforce a hard rule at the end-of-turn event.

hookify rules are Markdown files stored in the project’s .claude/ directory, with filenames such as hookify.<rule-name>.local.md. Rule changes take effect on the next tool call without a restart. The frontmatter uses several fields:

Field Values
event bash, file, stop, prompt, all
action warn (default) or block
pattern A regular expression for simple matching
conditions Multiple conditions, each containing field, operator, and pattern

First, consider the bundled blocking rule. It blocks commands such as rm -rf:

---
name: block-dangerous-rm
enabled: true
event: bash
pattern: rm\s+-rf
action: block
---

⚠️ **Dangerous rm command detected!**
Enter fullscreen mode Exit fullscreen mode

Under Python 3.10, feeding a Bash tool-call event to its pretooluse.py produces permissionDecision: "deny" together with the rule body. Feeding it ls -la produces an empty object and does not block. In other words, the blocked command never executes, and Claude receives the rule body as the reason.

Now consider the requirement that tests must pass before work can end. The official examples include a require-tests-stop.local.md rule, disabled by default. There is a trap in that example: its pattern is npm test|pytest|cargo test, but the operator is not_contains. Reading the rule engine’s source shows that not_contains is implemented as Python’s pattern not in field_value—a literal substring check, not a regular expression. The entire pipe-separated string will therefore never appear in the transcript, so the rule blocks forever even after tests have run. Testing confirms this: once the example is enabled, it returns block whether or not the transcript contains pytest.

Changing it to one literal substring fixes the problem:

---
name: require-tests-run
enabled: true
event: stop
action: block
conditions:
  - field: transcript
    operator: not_contains
    pattern: pytest
---

Before finishing, run pytest and include the result.
Enter fullscreen mode Exit fullscreen mode

Tests with two simulated transcripts produce the expected result: a transcript without pytest returns {"decision": "block", "reason": ...}, while one containing pytest returns an empty object and is allowed through. If you want to recognize several different test commands, change operator to regex_match and use a regular expression that expresses “does not contain.”

This Stop rule maps directly to the behavior described earlier. When Claude tries to finish, the rule reads the transcript. If no tests were run, it prevents the turn from ending and returns the rule body as the reason, prompting Claude to continue working.

There are two other hookify caveats.

Python version. The README says Python 3.7 or later, but the source in config_loader.py uses syntax such as tuple[Dict[str, Any], str], which requires Python 3.9 or later. In testing, Python 3.8.10 raises TypeError: 'type' object is not subscriptable during import and crashes the hook; Python 3.10.20 and 3.12.14 work correctly.

The hook commands hard-code python3. Every command in hookify’s hooks.json is written as python3 "${CLAUDE_PLUGIN_ROOT}/hooks/xxx.py". Unlike security-guidance, it has no interpreter-detection script. On Windows, the default python3 is often the Microsoft Store placeholder and produces a “Python was not found” message. Before installing hookify on Windows, run python3 --version in Git Bash and confirm that it reports version 3.9 or later.

7. Language Servers, Context7, and Playwright: Let It See, Look Things Up, and Click

The plugins discussed so far add constraints and workflows. This section covers three kinds of capabilities, all with 0 persistent overhead.

Language servers (see). The official marketplace includes language-specific plugins such as typescript-lsp, pyright-lsp, gopls-lsp, rust-analyzer-lsp, and jdtls-lsp. They give Claude two things: errors and warnings from the language server after every edit, allowing it to catch newly introduced type errors or missing imports before running a build; and symbol-based definition and reference lookup instead of plain text search.

The plugin tells Claude Code how to launch the language server, but you must install the binary yourself. For TypeScript, for example:

npm install -g typescript-language-server typescript
Enter fullscreen mode Exit fullscreen mode
/plugin install typescript-lsp@claude-plugins-official
Enter fullscreen mode Exit fullscreen mode

To verify that it works, ask Claude to deliberately introduce a type error and then fix it. If you see “Found N new diagnostic issues in M files,” the server is running. If not, open the Errors tab under /plugin; an Executable not found in $PATH line will identify the missing binary. Note that the official documentation says code-intelligence plugins work in terminal sessions but do not start in cloud sessions.

Context7 (look things up). Context7 is a documentation-query service built by Upstash. The official marketplace version connects to a hosted remote MCP service, so it does not require a local Node installation. Its purpose is to place current-version documentation and examples for a library directly into the context, reducing outdated code patterns. Add use context7 to the end of a prompt. To target a specific library, include its library ID; to target a particular version, write the version directly in the question. It exposes two tools: resolve-library-id and query-docs. The service recommends configuring an API key for higher request limits.

Playwright (click). Microsoft’s browser-automation MCP service is configured by the plugin to start @playwright/mcp@latest through npx. It lets Claude open pages, take screenshots, fill in forms, and click elements, making it useful for having Claude walk through a frontend after making changes. Because it starts a local process, it requires a Node environment and runs with your user permissions.

There is also a github plugin that connects to GitHub’s hosted MCP service and authenticates through the GITHUB_PERSONAL_ACCESS_TOKEN environment variable. Keep the token’s permission scope as narrow as possible.

Everything in this section comes from official documentation and configuration files in the plugin repository. These plugins were not individually run on the test machine.

8. Fable 5.2 in Editors: Official Extensions and Third-Party Plugins

Outside the terminal, most people also use Claude in an editor. We will start with the two official integrations.

VS Code extension. This requires VS Code 1.94.0 or later. Search for Claude Code in the Extensions view to install it. It shares ~/.claude/settings.json with the command line, and plugins and marketplaces are available in both. Enter /plugins in the extension to manage them. To switch models, use the model selector at the bottom of the input box, or enter /model in version 2.1.284 or later. The extension does not add claude to PATH, so you must install the command-line version separately if you also want to use it in a terminal. Set environment variables through the extension’s claudeCode.environmentVariables setting.

JetBrains plugin. This integration runs claude in the IDE terminal and connects to it; it does not bundle the CLI, so install the command line first. On Windows, the quick-open shortcut is Ctrl+Esc. Changes open in the IDE’s own diff view, the currently selected text is shared automatically, and the plugin can pass IDE inspection results to Claude through getDiagnostics. Use /ide to connect from an external terminal. WSL users should set the Claude command in Settings to wsl -d <distribution> -- bash -lic "claude".

Now for the third-party options: Cline, Roo Code, and Continue. Their official documentation confirms the following:

  • Cline: select Anthropic under API Provider in Settings, enter your key, and choose a model from the Model dropdown. An optional Use custom base URL checkbox lets you specify a custom endpoint. When Claude is selected, an Enable Extended Thinking checkbox is also available.
  • Roo Code: the steps are nearly identical to Cline, including the Use custom base URL option.
  • Continue: use provider: anthropic, model, and apiKey in YAML. Its documentation page does not mention an apiBase field, so support for custom endpoints depends on the configuration reference for the version you are using.

None of those three tools’ documentation pages mentions Fable 5.2, so this article cannot confirm whether the model appears directly in their selectors. What we can do is list the request patterns that cause Fable 5.2 to return HTTP 400, so you can check the client’s settings:

Request includes Result Fix
thinking: {"type": "disabled"} or thinking.budget_tokens 400 Omit thinking, or pass {"type": "adaptive"} and control depth with effort
temperature, top_p, or top_k 400 Remove all of them
A prefilled assistant message 400 Use a system prompt or structured output instead
tool_choice set to any or a specific tool 400 Use auto with explicit instructions
Earlier conversation turns have been modified 400 with The block is bound to a different conversation Keep history append-only

The last row affects only programs that construct their own requests. According to the official documentation, it does not affect requests assembled by Claude Code, claude.ai, Managed Agents, or the Agent SDK.

There is also an account-level prerequisite: Fable 5.2 requires 30-day data retention. It is unavailable to zero-data-retention organizations, and their requests are rejected.

9. Unify Your Endpoints: Connect Claude Code and Editors Through RelayRouter

Once the plugins are installed, one familiar problem remains: the terminal, VS Code, JetBrains, Cline, CC Switch, and other clients each need the endpoint, key, and model name entered separately. The same three variables from the previous article appear again here. Consolidating them behind one endpoint eliminates much of that duplication.

RelayRouter describes itself as a unified access platform for calling multiple AI capabilities through a single interface, with support for common protocols, usage-based billing, and centralized management of calls and spending. Its example repository clearly documents which endpoint to enter for several types of clients. Here is the condensed version:

Client Endpoint Notes
Claude Code; the Claude tab in CC Switch https://api.relayrouter.app Anthropic format; Claude Code appends /v1/messages itself
Clients that support only a general-purpose protocol https://api.relayrouter.app/v1 The default SDK pattern in the example repository
Clients requiring the complete endpoint https://api.relayrouter.app/v1/chat/completions Use only when the client explicitly requires a full endpoint

The example repository recommends trying the three endpoints in that order because different clients expect different forms.

Step 1: Get a key. If you do not have an account, you can register and sign in to the RelayRouter console, create a key in the console, and confirm in the available-model list whether claude-fable-5-2 is enabled for your account. The official Claude Code documentation notes that an endpoint not configured to provide that model name will reject requests for it.

Step 2: Configure Claude Code.

export ANTHROPIC_BASE_URL="https://api.relayrouter.app"
export ANTHROPIC_AUTH_TOKEN="YOUR_API_KEY"
claude --model claude-fable-5-2
Enter fullscreen mode Exit fullscreen mode

Windows PowerShell:

$env:ANTHROPIC_BASE_URL = "https://api.relayrouter.app"
$env:ANTHROPIC_AUTH_TOKEN = "YOUR_API_KEY"
claude --model claude-fable-5-2
Enter fullscreen mode Exit fullscreen mode

For a persistent configuration, place the values in the env block of ~/.claude/settings.json (on Windows, %USERPROFILE%\.claude\settings.json). Do not put the token in the project’s .claude/settings.json, because that file may be committed:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.relayrouter.app",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY",
    "ANTHROPIC_MODEL": "claude-fable-5-2"
  }
}
Enter fullscreen mode Exit fullscreen mode

The official documentation maps these variables to request headers as follows: ANTHROPIC_AUTH_TOKEN is sent as Authorization: Bearer, while ANTHROPIC_API_KEY is sent as x-api-key. If you do not know which one the endpoint expects, try the former first; if it returns 401, switch to the other variable.

Step 3: Verify first, then start a session. The official documentation provides a one-token request. Replace the endpoint and token with the variables above:

curl -sS -w '\n%{http_code}\n' -X POST "$ANTHROPIC_BASE_URL/v1/messages" \
  -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model": "YOUR_MODEL_NAME", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'
Enter fullscreen mode Exit fullscreen mode

If the response is JSON beginning with {"id":"msg_, the endpoint and key are working. A response saying that the model does not exist also confirms that the endpoint and key are valid—you simply need a different model name. After entering a session, run /status and check whether the Anthropic base URL line shows the endpoint you entered.

Step 4: VS Code. Put the environment variables in VS Code’s own user settings:

{
  "claudeCode.environmentVariables": [
    { "name": "ANTHROPIC_BASE_URL", "value": "https://api.relayrouter.app" },
    { "name": "ANTHROPIC_AUTH_TOKEN", "value": "YOUR_API_KEY" }
  ]
}
Enter fullscreen mode Exit fullscreen mode

The following behavior was measured with Claude Code 2.1.329 against a simulated local endpoint. No real service was involved. These results can help identify which setting is wrong:

Configuration Measured result
ANTHROPIC_BASE_URL without /v1 Request is sent to /v1/messages?beta=true, as expected
ANTHROPIC_BASE_URL incorrectly includes /v1 Request becomes /v1/v1/messages; Claude Code says the selected model “may not exist or you may not have access,” even though the endpoint is the actual problem
ANTHROPIC_AUTH_TOKEN Sends only Authorization: Bearer, not x-api-key
ANTHROPIC_API_KEY Sends only x-api-key, not Authorization
Endpoint returns HTTP 200 with an HTML page Reports “API returned an empty or malformed response (HTTP 200)” instead of treating it as a valid reply
CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 Reduces the number of values in the anthropic-beta header from 8 to 3

The second row is particularly misleading: the endpoint is wrong, but the error message blames the model. When you see that message, check the endpoint first and the model name second. The final row is useful when an endpoint returns 400 for unfamiliar new fields; the official troubleshooting table recommends it as well.

One final reminder: the RelayRouter console is the source of truth for supported models and pricing. The endpoint patterns above come from its example repository and the official Claude Code documentation; they were not tested against RelayRouter using a real key. Run the Step 3 verification command before relying on them.

10. Closing Thoughts

Looking back, this article is really about one habit: before installing a plugin, ask whether it adds a capability, a constraint, or a workflow. Then use the official command to measure its persistent overhead, check whether it launches additional subagents, and determine whether it runs commands on your machine.

Following that habit, if you choose only a few from this article:

  • To keep large features from going off track: feature-dev, with about 240 persistent tokens and a workflow that hard-codes the points where it must pause and ask you.
  • To add an independent verification pass before merging: code-review, with about 22 persistent tokens; remember that a single review launches at least 7 agents.
  • To check Claude-written code automatically for security issues: security-guidance, with 0 persistent tokens; the cost lies in Opus usage at the end of turns and at commit time, and Windows users should confirm Python first.
  • To turn “do not stop early” into a rule: hookify; note the Python 3.9+ requirement and the not_contains trap in the example.
  • To let Claude see, look things up, and click: the LSP plugin for your language, Context7, and Playwright.

This article covers only a small subset. It does not examine all 317 entries one by one, explain how to write your own plugin, or claim more about third-party editor support for Fable 5.2 than their documentation can verify. The LSP, Context7, Playwright, GitHub, and editor sections rely entirely on official documentation and plugin repository files; they were not individually tested on the local machine. hookify’s hook output, the plugin details overhead figures, and the requests sent by Claude Code were tested directly.

In practice, add only one plugin at a time. After installation, measure it with claude plugin details. After using it for a while, check the Not used recently group under /plugin and disable anything you do not use. Disabling does not require uninstalling: use claude plugin disable <name>. To uninstall, use claude plugin uninstall <name>.

In one sentence: Install only plugins that add a capability or constraint, measure before you commit, and keep only what you actually use.

If this article helped, please like, save, and follow. If you run into problems while configuring your setup, describe them in the comments—and remember to redact your token first. See you next time.

Disclosure: YOUR_API_KEY and YOUR_MODEL_NAME in the examples are placeholders; replace them with your own values. The test environment was Claude Code 2.1.329 with official plugin repository commit d7d3279 (2026-11-19); figures may vary, so rely on command output from your own machine. Images in this article were generated by AI. Source references (all official documentation paths): under code.claude.com/docs/en—plugins/overview, plugins/install, plugins/measure, plugins/security, plugins/code-intelligence, security-guidance, prompt-caching, the gateway connection guide, model-config, vs-code, and jetbrains; under platform.claude.com/docs/en/models/fable-5-2—whats-new-fable-5-2 and migration-guide.

Top comments (0)