superview.sh: A Two-Line Reroute That Turns Claude Code Into a Logged, Auditable Agent

What superview.sh Actually Does

The repository is a thin shell script that changes two environment variables so Claude Code sends its API traffic to a hosted gateway instead of Anthropic's endpoint. The README presents it as a way to see what your Claude Code actually sends: every request, every file it reads, every token it burns. The mechanism is intentionally minimal. You export ANTHROPIC_BASE_URL to https://aigateway.leanmcp.com/v1/anthropic and ANTHROPIC_API_KEY to your LeanMCP key. That is the entire setup. No agent installation, no editor plugin, no proxy to run locally. The script itself is not shown in the README, only the two export lines. Based on the repository layout and description, superview.sh is likely a convenience wrapper that sets these variables and then launches Claude Code, but the exact contents are not documented in the supplied material. What is clear is that the project does not add logging code to Claude Code; it reroutes the traffic so the gateway can record it.

Who This Is For

The target user is a developer who already runs Claude Code and wants to know what the agent is doing without reading raw terminal output. The README's pitch is directed at individuals and teams who are concerned about hidden activity: what files are read, what prompts are sent, how many tokens are consumed. It is also aimed at people who want a dashboard view, not a log file. The project sits at the intersection of observability and cost control. If you are a solo developer who trusts Claude Code but wants a paper trail, this gives you that with two lines. If you are a team lead who needs to audit agent behavior across several developers, the hosted dashboard is the draw. The description also mentions that the gateway is part of a larger AI gateway product from LeanMCP, so this is not a standalone tool but a front door to a commercial service.

The Mechanism: Environment Variable Rerouting

The core mechanism is the ANTHROPIC_BASE_URL environment variable. Claude Code, like most Anthropic SDK clients, respects this variable to override the default API endpoint. By setting it to aigateway.leanmcp.com, all requests from Claude Code go to LeanMCP's server first. The gateway then forwards them to Anthropic, records the request and response metadata, and returns the result to Claude Code. The ANTHROPIC_API_KEY is replaced with a LeanMCP key, which means the gateway can authenticate the user and associate logs with an account. This is a classic MITM proxy pattern, but the proxy is hosted and external. The README claims 'no code required' and 'one URL change', which is technically true for the user, but the code change is in the environment, not in Claude Code. The data flow is simple: Claude Code sends a request, the gateway sees it, logs it, forwards it, and the dashboard at app.leanmcp.com shows the log. This design means the gateway has full visibility into your prompts, file contents, and tool calls. That is the point, but it is also the risk.

Getting It Running: Commands and Config

The README gives exactly two commands to get started. First, export the base URL and API key in your shell: export ANTHROPIC_BASE_URL=https://aigateway.leanmcp.com/v1/anthropic and export ANTHROPIC_API_KEY=your_leanmcp_key. Then run any Claude Code task. The logs appear in the dashboard at app.leanmcp.com. To get a key, you visit app.leanmcp.com/billing. There is no mention of installing a package, cloning the repo, or running a script. The project name superview.sh suggests there might be a shell script that does the export for you, but the README does not show it. If you want to use it, the safest assumption is to replicate the two export lines yourself. You also need to ensure these variables are set in the same shell session where you launch Claude Code, otherwise the rerouting does not apply. The README does not mention how to persist these variables across sessions, but you could add them to your shell profile. There is no mention of a config file, so environment variables are the only configuration surface.

A Genuine Limitation: Trusting a Hosted Proxy With Your Code

The most obvious limitation is that you are sending your source code and prompts through a third-party server. The README does not state what LeanMCP does with the data, how long logs are retained, or whether the gateway encrypts payloads beyond standard TLS. For developers working with proprietary code, healthcare data, or anything covered by NDAs, this is a non-starter. The README itself argues that open-source tools solve privacy concerns by giving you control over data, but this project does the opposite: it funnels everything to a hosted service. The documentation also does not mention any self-hosting option for the gateway. Another limitation is that the dashboard only shows what the gateway sees. If Claude Code uses local tools or reads files that are not sent to the API, those actions will not appear in the logs. The README claims 'every file it reads', but that is only true if the file content is included in the API request, which it often is for context, but not always for every operation. Finally, if the LeanMCP gateway goes down, your Claude Code stops working because all traffic is routed through it. There is no fallback mentioned.

The Alternative: Local Proxy or Direct API Logging

The direct alternative is to run a local proxy that logs requests before forwarding them to Anthropic. Tools like LiteLLM or a simple mitmproxy script can sit on localhost, capture the same ANTHROPIC_BASE_URL traffic, and write logs to a file or a local database. The difference in approach is location and control. With superview.sh, the logging happens on a remote server, and you have no access to the raw logs unless the dashboard exposes them. With a local proxy, the logs live on your machine, you can rotate them, redact them, and you never send your API key to a third party. The trade-off is setup effort. A local proxy requires you to install, configure, and maintain a service, and you have to build the dashboard yourself or use a log viewer. The README's pitch is that superview.sh gives you the dashboard without any work. That is true, but the cost is that the proxy operator sees everything. Another alternative is to use Anthropic's own admin logs if you are on a team plan, but that only shows API usage, not the detailed request contents that superview.sh claims to show.

Maintenance, License, and Upgrade Cost

The repository is licensed under MIT, which means you can fork and modify the script freely. However, the script is just a wrapper; the actual service is closed and hosted by LeanMCP. The README does not mention any versioning or release history, and the last push is unknown. There are no recent releases listed, which suggests the project is either very new or not actively maintained in terms of tags. The maintenance cost for the user is low: you set two environment variables and you are done. But you depend on the gateway's uptime and API compatibility. If Claude Code changes how it reads ANTHROPIC_BASE_URL or introduces a new header, the gateway might break, and you would need to wait for LeanMCP to update. The license does not cover the gateway service, so you cannot self-host it even though the script is MIT. The upgrade cost is also tied to the commercial service: if LeanMCP changes pricing or features, your logging setup changes with it. The README links to a billing page, so this is a paid service, but no pricing is listed in the material.

Editorial conclusion

Adopt superview.sh if you run Claude Code and need immediate, centralized visibility into what the agent sends and reads, with no code changes. Skip it if you require self-hosted logging, want to avoid sending traffic to a third-party gateway, or need fine-grained control over log retention and access. Before adopting, verify the gateway's data retention policy, whether the proxy encrypts payloads in transit and at rest, and what happens to your API key if you rotate it. The real value is the two-line setup: if that simplicity is not worth the trust trade-off, a local proxy or direct API logging gives you the same insight without the hosted dependency.

Official sources

1. Official documentation
2. Official README
3. Project repository