> ## Content Index > Fetch the complete content index at: https://www.implicator.ai/llms.txt > Use this file to discover other available public pages before exploring further. # Four GitHub Tools That Stop Claude, Codex, and Gemini From Shipping Bad Code - URL: https://www.implicator.ai/four-github-tools-that-make-claude-codex-and-gemini-less-wrong/ - Published: 2026-04-28T10:00:26.000Z - Updated: 2026-10-21T15:22:44.000Z - Description: Four open-source tools fix four different failure modes in terminal AI. Superpowers teaches the agent how to work. Context7 feeds it current docs. Serena gives it IDE-grade code navigation. ccusage tells you what the other three cost. Here is how to install them and the commands that actually matter - Author: Marcus Schuler - Tags: Implicator PRO Briefing *Implicator PRO Briefing / 28 Apr 2026* | | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Pro Members Only Terminal AI has a correctness problem that no single model upgrade fixes. The agent skips tests, hallucinates SDK methods, and burns through tokens you cannot see in real time. This briefing walks through four open-source tools that address four distinct failure modes. Installation paths for Claude Code, Codex CLI, and Gemini CLI. The ten or so commands that actually matter. The research backing each mechanism, and the field evidence that says tool adoption alone does not guarantee productivity. A disciplined stack, not a plugin buffet. New to Implicator PRO? [Subscribe for the/month](https://www.implicator.ai/become-an-implicator-pro-member/) — new deep dive every Tuesday morning 3am PST. | | | The coding agent hits Enter. A plausible patch appears. It references an SDK method that was renamed six months ago, touches three files it should not have touched, and skips the test entirely. The terminal says "Done." It is not done. Every engineer who has let Claude Code, OpenAI Codex, or Gemini CLI drive a real task has lived some version of this scene. The model is confident. The code compiles. Production breaks on Tuesday. The post-mortem blames prompting, context, or model choice. The truth is usually simpler. The agent had the wrong habits, the wrong docs, and no structured view of the repository it was editing. Four open-source tools on GitHub address those three failures directly. Superpowers from obra teaches the agent how to work. Context7 from Upstash feeds it current library documentation. Serena from Oraios gives it IDE-grade semantic navigation. And ccusage from ryoppippi tells you what the other three are actually costing. Together they turn terminal AI from a confident intern into something closer to a disciplined collaborator. This briefing walks through the failure modes, the installation paths, and the handful of commands each tool actually needs. The stack works across Claude Code, OpenAI Codex CLI, and Gemini CLI. The reasoning comes from a deep-research package assembled on April 22, 2026, cross-checked against repository metadata, package registries, and the Model Context Protocol specification. The numbers will move. The architecture should not. The Stack - Four open-source tools fix four different terminal-AI failure modes. Superpowers changes agent behavior, Context7 retrieves current public-library docs, Serena provides IDE-grade semantic code navigation, ccusage measures what it all costs. - All four work across Claude Code, OpenAI Codex CLI, and Google Gemini CLI. Three connect through the Model Context Protocol, which makes them portable and also expands the agent's trust boundary. - Research evidence backs the mechanisms but not a universal productivity win. Documentation retrieval drove 83 to 220 percent gains in one API-RAG study. METR's 2025 field study showed 19 percent slowdowns when tooling was added without measurement. - Install the layer that matches your failure, not the full stack at once. Pilot, baseline, measure, and only then compose. AI-generated summary, reviewed by an editor. [More on our AI guidelines](https://www.implicator.ai/about/). ## Why the terminal became the battleground Terminal coding agents look like a convergence story. Claude Code, Codex CLI, and Gemini CLI all drop into a shell, read the working directory, edit files, and run commands. The user experience is almost identical. The underlying models are not. The governance is not. And the failure surface is absolutely not. Anthropic introduced the Model Context Protocol in November 2024 as an open standard for connecting AI assistants to external data and tools. The goal was to replace one-off integrations with a shared substrate. By spring 2026 the substrate had arrived. MCP servers now populate a public registry, the protocol roadmap covers streamable HTTP, sessions, discovery metadata, authentication, and extensions, and MCP Apps are pushing beyond tool calls into sandboxed interactive UI. That is the good news. The bad news is that standardization did not create correctness. A coding agent fails for at least three separable reasons. Sometimes it has the wrong process. It jumps into code without clarifying goals, writes a broad patch without a test, or skips the review pass that would have caught the regression. Sometimes it has stale external knowledge. It writes code for an old Next.js version, an old OpenAI SDK, or a deprecated Vite config because its training memory is 18 months behind the actual API. Sometimes it has weak local context. It knows the language but cannot efficiently find the symbol, reference, project convention, or safe edit boundary inside a large repository. Research has been pulling the same lesson out of different angles. ContextBench ran 1,136 tasks across 66 repositories and found coding agents favoring recall over precision, with persistent gaps between context retrieved and context actually used. CODERAG-BENCH showed documentation retrieval helping code generation while flagging retrieval quality as the remaining bottleneck. An API-documentation RAG study on 1,017 APIs across four less-common Python libraries reported performance improvements of 83 to 220 percent when retrieval was added, example code contributing more than parameter descriptions alone. Then came the uncomfortable counterweight. METR's 2025 field study watched 16 experienced developers work on 246 real issues in large open-source repositories. Early-2025 AI access made them 19 percent slower, even though they expected a 24 percent speedup and later believed they had been faster. Field friction hides inside demos. Tool adoption is not automatically productivity. That is the context behind the four tools below. They are not a leaderboard. They are a layered defense, and the layer you need first depends on which failure is costing you the most. > The right question is not "does this tool sound useful?" It is "which measured failure does it reduce, and what new cost does it introduce?" ## Four tools, four failure modes The cleanest way to compare the four is by the failure each actually attacks. Mix them up and you will install the wrong one and wonder why nothing changed. **Superpowers** sits at the procedural layer. Its README frames the project as an agentic skills framework and software-development methodology rather than a single command. The workflow examples include brainstorming, git worktrees, writing plans, executing plans, subagent-driven development, TDD, requesting code review, and finishing branches. The `using-superpowers` skill tries to make skill invocation mandatory when a relevant skill might apply, while preserving user instructions as the highest priority. If those habits take hold, every other tool in the stack improves because the agent has learned when to call them. **Context7** sits at the external-knowledge layer. Its README targets outdated examples, hallucinated APIs, and generic answers by pulling up-to-date, version-specific documentation and code from source into the prompt. It ships in two flavors: a CLI called `ctx7` and an MCP server at `@upstash/context7-mcp`. The right target is fast-moving public dependencies. The wrong target is private-code questions, where it cannot help. **Serena** sits at the local-code layer. The README calls it "the IDE for your coding agent" and exposes symbol lookup, references, symbolic editing, rename, safe delete, memory, and project configuration through MCP. Underneath it runs on the Language Server Protocol plus an optional JetBrains backend, which means it inherits the symbol knowledge that human IDEs already provide. Best fit: large or unfamiliar repositories where grep-and-pray is eating tokens and missing call sites. **ccusage** sits at the observability layer. Where the other three change what the agent does, ccusage tells you what the agent did and what it cost. It reads local Claude Code JSONL logs, calculates token usage and cost by day, month, session, and five-hour billing window, and ships a statusline integration for live context. Companion packages extend the same treatment to Codex and OpenCode. Without it, budget awareness is guesswork. The distinction matters because operators keep substituting one for another. Context7 is not better grep. Serena is not live documentation. Superpowers is not just another MCP server. ccusage is not a productivity app. The diagnostic question is narrow: where is the recurring failure? Skipped tests and reckless edits point to Superpowers. Outdated framework code points to Context7\. Missed references and bloated file scans point to Serena. A credit card bill that hurts points to ccusage. 83–220% code-generation improvement from documentation retrieval, per 1,017-API RAG study ## Superpowers: the process layer Superpowers is structurally different from the other three. Every MCP server provides something the model may call. Superpowers tries to shape when the model asks questions, plans, writes tests, delegates, reviews, and stops. That is governance by instruction, which is both its strongest card and its biggest risk. The repository, `obra/superpowers`, was pushed on April 16, 2026, updated on April 22, 2026, and licensed MIT. The latest release as of this writing is v5.0.7 from March 31, 2026, which added GitHub Copilot CLI support and SessionStart context injection. Star count of roughly 164,000 is startling for a non-model repository and speaks to a real community, not a marketing push. ### How it installs Claude Code users get the fastest path through the official marketplace: ```bash /plugin install superpowers@claude-plugins-official ``` That command is typed inside Claude Code itself. The plugin registers the Superpowers skills directory, wires up startup context injection, and exposes skills to the Skill tool. Codex CLI, Gemini CLI, Copilot CLI, Cursor, and OpenCode each have their own install path in the repository README. The point to verify after any install is not presence. It is triggering. A skill that lives on disk but never fires is inert. ### The commands that matter Superpowers does not have "commands" in the traditional CLI sense. It has skills, each with a frontmatter trigger description the model reads before deciding to load the body. The ones worth knowing by name: - `superpowers:brainstorming`. the creative-work entry point. Triggers before feature work, component building, or behavior changes. It forces intent exploration before code. - `superpowers:writing-plans`. converts a spec into a step-by-step implementation plan with critical files named. - `superpowers:executing-plans`. runs a written plan in a separate session with review checkpoints. - `superpowers:test-driven-development`. RED-GREEN-REFACTOR, enforced. Write a failing test. Watch it fail. Implement the smallest fix. Watch it pass. - `superpowers:systematic-debugging`. applied to every bug, test failure, or unexpected behavior before proposing fixes. - `superpowers:requesting-code-review`. runs before merges to verify work meets requirements. - `superpowers:verification-before-completion`. requires running commands and confirming output before any success claim. - `superpowers:using-git-worktrees`. creates isolated git worktrees so feature work does not contaminate the current workspace. Invocation is usually implicit. The model reads the trigger, decides the skill applies, and uses the Skill tool to load the body. You can also invoke directly by saying "use the brainstorming skill" or by typing `/superpowers:brainstorm` if your client supports slash commands. ### Where it earns its keep The strongest Superpowers case is when procedural failure dominates. An agent that rushes, skips tests, ignores review, or does not check its own assumptions is not fixed by more information. It is fixed by changing its defaults. Embedded workflows like TDD and plan-execute-review compound across every downstream task. That advantage is conditional. Skill-writing practitioners have documented the trigger problem in detail. The model initially sees only frontmatter and description. The full body loads after selection. A beautifully written skill can fail silently if its trigger is too vague, too narrow, or too broad. Philipp Schmid's Gemini-API skill went from 66.7 to 100 percent pass rate after proper trigger evaluation, which is evidence that skills are testable artifacts, not essays. ### Pitfalls Superpowers is not a correctness oracle. It cannot prove a patch is safe, a retrieval is accurate, or an LSP reference set is complete. It can require the agent to seek evidence. The evidence still needs to be good. Two specific traps. First, the "even 1% chance, invoke the skill" policy reduces under-triggering but can cause over-triggering in small scopes. Tiny one-line changes should not trigger heavyweight planning. Second, a skill that says "ask for review" fails if review is performed by the same agent without sufficient context or adversarial stance. Real review means a different stance, ideally a different context window, sometimes a human. ## Context7: the external-docs layer The Context7 pitch is unusually crisp. The model should not write code against a moving API using only stale training memory. Its README targets outdated examples, hallucinated APIs, and generic answers by retrieving current, version-specific documentation and examples into the prompt at the moment of generation. The repository, `upstash/context7`, was created March 26, 2025, pushed April 21, 2026, and licensed MIT. Stars: 53,431\. Forks: 2,528\. Open issues: 127\. The ecosystem attention is real. Both GitHub and Microsoft highlighted Context7 among sponsored open-source AI and MCP projects in late 2025\. The observed npm versions split interestingly: `@upstash/context7-mcp` at 2.1.8 for the MCP server, and `ctx7` at 0.3.13 for the CLI, which requires Node 18 or newer. ### How it installs The fastest path is the setup wizard, which handles OAuth, API-key generation, and client-specific skill installation in one shot: ```bash npx ctx7 setup ``` The wizard accepts target flags such as `--cursor`, `--claude`, or `--opencode` to install only the skill file for one client. For manual MCP setup in Claude Code, Codex CLI, or Gemini CLI, point the client at `https://mcp.context7.com/mcp` and pass your key via the `CONTEXT7_API_KEY` header. Free API keys live at context7.com/dashboard. A key is not strictly required, but rate limits are noticeably stricter without one. ### The commands that matter Two MCP tools carry almost all the value: - `resolve-library-id`. converts a general library name into a Context7-compatible identifier. Parameters: `query`, `libraryName`. Use this first when you are unsure which exact package the agent should target. - `query-docs`. fetches documentation for a given library ID. Parameters: `libraryId`, `query`. Use this for the actual retrieval. The CLI mirrors the same two capabilities for skill-driven environments: ```bash ctx7 library react-query "cache invalidation on mutation" ctx7 docs /tanstack/query/v5 "useMutation onSuccess optimistic update" ``` The pattern is always the same. Resolve first. Query second. Pin a version when you can. Vague retrieval against the wrong library wastes the round trip and pollutes the context window. ### Where it earns its keep Greenfield code against fast-moving public dependencies. Framework upgrades. SDK migrations. Cloud service clients. Database libraries. AI APIs. Anywhere the model's latent memory is likely 12 months behind reality, Context7 is a direct counterweight. The empirical support sits at the mechanism level, not the tool level. The API-documentation RAG study measured 83 to 220 percent improvement across 1,017 APIs in four less-common Python libraries, with example code carrying more weight than parameter descriptions. CODERAG-BENCH reported gains from canonical documentation in benchmark settings while flagging retrieval quality as the bottleneck. These do not validate Context7 specifically. They validate what Context7 does. ### Pitfalls Three specific ones. First, the backend is private. The repository contains the MCP server source; the parsing and crawling engine live behind Upstash's hosted infrastructure. An open issue on the repo explicitly frames the concern. Context7 is a dependency on a hosted service, not a self-contained index. Second, the README warns that projects are community-contributed and may not be accurate, complete, or secure. Treat retrieved docs as evidence, not authority. Third, retrieval noise is real. The RAG study flagged missing correct documents, noisy context, wrong API selection, and hallucinated usage despite retrieval. Be specific in queries. Pin versions. Validate with tests. > Serena is the IDE for your coding agent. Superpowers tells it when to open the IDE. ## Serena: the local semantic-code layer Serena's pitch points inward. Where Context7 answers "what does this library look like today," Serena answers "what does this repository look like right now, by symbol, by reference, by call site." The README calls it "the IDE for your coding agent." The architecture backs the claim. The repository, `oraios/serena`, was created March 23, 2025, pushed April 22, 2026, and licensed MIT. Stars: 23,251\. Forks: 1,558\. The primary language is Python. The relevant PyPI package is `serena-agent`, not the unrelated `serena` package, which is an AMQP client. The observed version is 1.1.2, with Python `>=3.11,<3.15`. The changelog since 1.0.0 shows monorepo support, JetBrains backend, improved setup flows, usage reporting, certificate verification, ignored-path handling, tool exclusions, and security-oriented memory/path fixes. Active development, not abandoned demo. ### How it installs The README explicitly warns against stale marketplace install commands because they have drifted from reality multiple times. Use uv: ```bash uv tool install -p 3.13 serena-agent@latest --prerelease=allow serena init ``` The `serena init` step runs a guided setup and writes a project configuration. For Claude Code, Codex CLI, or Gemini CLI, register the launch command as an MCP server in your client config. The Serena documentation has per-client snippets. Re-check them before install. They change. Get Implicator PRO every Tuesday Strategic AI news from San Francisco. No hype, no "AI will change everything" throat clearing. Just what moved, who won, and why it matters. Daily at 6am PST. Email address Subscribe Check your inbox. Click the link to confirm. No spam. Unsubscribe anytime. Language support runs across more than 40 languages through two backends. The free backend uses LSP servers that ship with most editors: `gopls`, `pyright`, `rust-analyzer`, `typescript-language-server`, and so on. The paid backend uses JetBrains plugins with a free trial. Both paths expose the same semantic primitives. ### The commands that matter Serena's MCP tools map to IDE operations, not file reads: - `find_symbol`. look up a symbol by name with optional scope and relative path. The starting point for any symbol-based investigation. - `get_symbols_overview`. file-level structural summary. Faster than reading the whole file when you want to see what is in it. - `find_referencing_symbols`. all call sites and references to a symbol, across the codebase. This is the one that earns its keep during refactors. - `replace_symbol_body`. replace a function or class body cleanly, without risking text-patch misses. - `insert_before_symbol` / `insert_after_symbol`. add code at a named boundary instead of guessing line numbers. - `rename_symbol`. language-server-backed rename that catches references, not a text search-and-replace. - `delete_symbol`. safe delete that checks references first. - `write_memory` / `read_memory` / `list_memories`. persistent notes the agent can recall across sessions. Project activation is done once per repository with `activate_project`, after which the tools operate against that project's indexed symbols. A dashboard runs locally to show indexing state, tool calls, and usage metrics, which helps when the backend goes sideways. ### Where it earns its keep Three situations dominate. First, large or unfamiliar codebases where the agent otherwise burns tokens on file discovery. Second, refactors and bug fixes where references and definitions matter more than isolated syntax. Third, multi-language or monorepo projects where conventions are distributed across packages. Serena's recent changelog work on monorepos, multi-language support, and query-other-projects behavior points exactly at this user. Research support is real but indirect. ContextBench's 1,136 tasks across 66 repositories showed coding agents favoring recall over precision with gaps between retrieved and utilized context. LoCoBench-Agent stressed agent behavior across contexts from 10K to 1M tokens. Semantic retrieval helps in both cases, if the retrieval is precise. ### Pitfalls Serena has a larger local trust boundary than Context7\. It is designed to inspect and edit local repositories, sometimes with memory. That is more powerful than read-only documentation retrieval and needs stronger guardrails. Start with read-only exploration. Confirm the language server actually indexes the repository correctly. Gate symbolic editing and rename behind explicit approval until you trust the backend. Serena's own recent changelog mentions read-only checks and tool exclusions for exactly this reason. The language-server dependency is a double-edged sword. LSP gives real semantic primitives. It also inherits whatever the underlying language server cannot do. Incomplete indexing, weak type inference, slow startup on a 200k-file repository, or confused project configuration will show up as missing references or wrong edits. Pilot one repository before enabling it everywhere. 5 hours the Claude Code billing window ccusage tracks in real time ## ccusage: the observability layer The first three tools change what the agent does. ccusage tells you what it cost, when it cost it, and whether the budget is about to crater before your billing cycle closes. It is the least glamorous of the four and often the one that pays for itself first. The repository, `ryoppippi/ccusage`, sits at about 13,200 stars with version v18.0.11 as of April 19, 2026\. It reads local JSONL logs written by Claude Code and calculates token use and cost without contacting an external service. Companion packages extend the same approach to neighboring ecosystems: `@ccusage/codex` for OpenAI Codex, `@ccusage/opencode` for OpenCode, `@ccusage/amp` for Amp, `@ccusage/mcp` for MCP integration. ### How it installs No install is needed for a quick look: ```bash npx ccusage@latest bunx ccusage pnpm dlx ccusage ``` For Claude Code specifically, there is a Bun-shortcut variant: ```bash BUN_BE_BUN=1 claude x ccusage ``` Permanent install is the same as any JS package. Most users never bother because `npx ccusage@latest` is already two keystrokes away from any terminal. ### The commands that matter Five subcommands carry the daily workflow: - `ccusage daily`. token usage and costs aggregated by date. The default report. Add `--since 20260401 --until 20260422` to scope a billing cycle. - `ccusage weekly`. same, aggregated by week. - `ccusage monthly`. same, aggregated by month. - `ccusage session`. grouped by conversation. Useful when one run blew up the spend. - `ccusage blocks`. the five-hour billing window view. The window opens on your first message and runs exactly five hours. New activity after expiry opens a new block. The blocks report carries the most operational value and the most flags: ```bash ccusage blocks --active # current window with time remaining and projections ccusage blocks --recent # last 3 days ccusage blocks --token-limit max # warn as you approach the plan ceiling ccusage blocks --session-length 8 # override the 5-hour default to 8 hours ccusage blocks --json # pipe to jq, Grafana, anything ccusage blocks --offline # skip model-pricing refresh ``` One warning. The `blocks --live` monitor was removed in v18.0.0\. The replacement is `ccusage statusline`, which prints a compact real-time line intended for Claude Code's statusline hook. Pair it with the Claude Code statusline config and budget awareness becomes ambient instead of a separate ritual. ### Where it earns its keep ccusage earns its keep three ways. First, cost audits. You will find sessions that burned a surprising number of tokens for an unsurprising amount of output, usually because the agent reread the same files fifty times. Second, plan sizing. Looking at a month of `ccusage monthly` against the Anthropic plan ladder is the fastest way to decide whether to move tiers. Third, runtime awareness. `ccusage blocks --active` inside a long Claude Code session shows when you are about to pay variable rates, which changes how aggressively you prune context. ### Pitfalls ccusage reads local logs, so what you see depends on what Claude Code wrote. Logs rotate. Old sessions age out. Running it on a fresh machine shows nothing until logs accumulate. Cost calculations depend on the pricing model bundled with the release, so a major pricing change means updating ccusage. And while ccusage is local, the data it exposes is sensitive enough that piping `--json` output into a shared dashboard deserves a second thought. ## The stack, assembled The four tools do not replace each other. They compose. The combined workflow looks different depending on the task. For a dependency-heavy change, Superpowers identifies the task as one that touches a fast-moving library. Context7 retrieves the specific version's docs with a precise library ID. The agent inspects local convention through Serena if the change touches multiple symbols. A focused test runs. Review follows. ccusage shows the whole thing cost $0.47 and used 18,000 output tokens in a single 22-minute block. For a large-repo refactor, the order shifts. Superpowers pushes into planning and scope control first. Serena finds symbol definitions, references, and safe edit points. Context7 is called only if the refactor touches an external API. Edits are semantically bounded, not text-patched. Review focuses on missed references, generated-code paths, and migration compatibility. ccusage shows a more expensive session, which is expected, and whether the tool calls were concentrated on one symbol or sprayed across the repo. For a review pass, the stance inverts. Superpowers puts the agent into review mode, findings-first, not summary-first. Serena traces references on suspicious changes. Context7 verifies whether a changed external API call matches current docs. The review does not assume a passing test suite is sufficient. Code-review research on agent-authored PRs shows testing, security, build configuration, documentation, styling, and refactoring issues all arising at review time. There is a harder truth underneath the stack. MCP standardization makes these tools portable across Claude Code, Codex CLI, and Gemini CLI, but every MCP server expands the agent's capability boundary. A 2026 security paper studied prompt-injection and tool-poisoning vulnerabilities in Claude Desktop, Claude Code, Cursor, Cline, Continue, Gemini CLI, and Langflow. OWASP's MCP Top 10 categorizes tool poisoning, authentication, authorization, and data exposure as distinct concerns. The four tools here are well-scoped, but they still need trust tiers. Context7 belongs in read-only public and networked external. Serena spans read-only local and write-local depending on configuration. Superpowers belongs in the instruction layer. ccusage is read-only local. Apply least privilege, not vibes. The decision rule is short. If the recurring failure is agent behavior, Superpowers is the first lever. If the failure is stale public-library knowledge, Context7 is the first lever. If the failure is local codebase navigation, Serena is the first lever. If the failure is cost visibility, ccusage is the first lever. None of them substitutes for tests, review, or a human who asks whether the change is actually correct. ## What to Watch The next 60 days will decide whether this stack holds together or fragments. Five signals are worth tracking. - **Superpowers: client coverage.** v5.0.7 added Copilot CLI and SessionStart context injection. Watch whether the next release consolidates Gemini CLI and Codex CLI parity or leaves them running behind the Claude Code integration. - **Context7: backend transparency.** The private parsing and crawling engine remains the governance gap. Watch for either a self-hostable tier or documented rate-limit behavior for the free API key. - **Serena: monorepo benchmarks.** The changelog between 1.0.0 and 1.1.2 points at monorepos and query-other-projects. Watch for a public benchmark against ContextBench-style tasks before the end of Q2 2026. - **ccusage: statusline adoption.** With `blocks --live` removed in v18, the statusline integration is the replacement. Watch whether Claude Code ships first-class support or ccusage stays a terminal-side overlay. - **MCP governance.** OWASP's MCP Top 10 is still early. Watch the next revision and the MCP roadmap items on authentication, discovery metadata, and events. Tool portability and tool safety are converging, slowly, into the same conversation. ### Key Takeaways - **Diagnose first:** Pick the layer that matches your failure. Tools installed as ornaments do nothing and add noise. - **Superpowers compounds:** Process discipline multiplies the value of every other tool because the agent now calls them at the right moment. - **Version everything with Context7:** Vague queries retrieve vague docs. Resolve the library ID first, then query with a pinned version. - **Serena is a trust decision:** It can rename across call sites. It can also make unsafe edits. Start read-only, graduate deliberately. - **ccusage turns spend into data:** \`blocks --active\` and the statusline integration change budget from a monthly surprise into an in-session signal. - **MCP is a trust boundary, not a plugin bay:** Every server expands what the agent can see or do. Classify tools by capability, not by name. - **Measure the stack locally:** METR found field productivity going backward in 2025 despite confidence to the contrary. Baseline, test, then trust. ### Sources & Further Reading #### The four tools - [Superpowers](https://github.com/obra/superpowers?ref=implicator.ai). obra, GitHub, 2026 - [Context7](https://github.com/upstash/context7?ref=implicator.ai). Upstash, GitHub, 2026 - [Serena](https://github.com/oraios/serena?ref=implicator.ai). Oraios, GitHub, 2026 - [ccusage](https://github.com/ryoppippi/ccusage?ref=implicator.ai). ryoppippi, GitHub, 2026 - [ccusage blocks reports guide](https://ccusage.com/guide/blocks-reports?ref=implicator.ai). ccusage docs, 2026 #### Protocol and standards - [Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol?ref=implicator.ai). Anthropic News, 2024 - [2026 MCP Roadmap](https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/?ref=implicator.ai). Model Context Protocol Blog, 2026 - [Language Server Protocol 3.17](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/?ref=implicator.ai). Microsoft, 2026 - [MCP Top 10](https://owasp.org/www-project-mcp-top-10/?ref=implicator.ai). OWASP, 2026 #### Research and analysis - [Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/?ref=implicator.ai). METR, 2025 - [When LLMs Meet API Documentation](https://arxiv.org/abs/2503.15231?ref=implicator.ai). Ye et al., arXiv, 2025 - [CODERAG-BENCH](https://aclanthology.org/2025.findings-naacl.176/?ref=implicator.ai). Ma et al., ACL, 2025 - [Are AI-assisted Development Tools Immune to Prompt Injection?](https://arxiv.org/abs/2603.21642?ref=implicator.ai). Ye et al., arXiv, 2026 - [Practical Guide to Evaluating and Testing Agent Skills](https://www.philschmid.de/testing-skills?ref=implicator.ai). Philipp Schmid, 2026 Frequently Asked Questions Do I need all four tools to benefit? No. Each tool targets a distinct failure mode. Install the one whose failure matches your pain. Undisciplined agents need Superpowers. Stale library code needs Context7\. Missed references in large repos need Serena. Invisible costs need ccusage. Stack them only when the bottleneck shifts. Will these work with OpenAI Codex CLI and Gemini CLI, not just Claude Code? Yes. Superpowers ships skills for Claude Code, Codex CLI, Gemini CLI, Copilot CLI, Cursor, and OpenCode. Context7 and Serena are MCP servers that register with any MCP-capable client. ccusage has companion packages for Codex and OpenCode alongside the core Claude Code tool. Is Context7 fully open source? The MCP server source is public and MIT-licensed. The parsing and crawling backend that actually ingests library documentation is a hosted Upstash service. That makes Context7 a dependency on a hosted API, not a self-contained index. Account for that in threat models and private-code query handling. Is Serena safe to use on production repositories? Serena can read, navigate, rename, and delete symbols. Start with read-only exploration and gate symbolic edits behind explicit approval. Verify the language server indexes your repository correctly. Use tool exclusions and memory controls in project config. The 1.1.x changelog added exactly these guardrails for a reason. Does ccusage send my data anywhere? No. It reads local Claude Code JSONL logs and calculates cost locally. Model pricing data is refreshed from the package, not streamed, and an --offline flag skips even that refresh. The data is still sensitive enough that piping --json output into a shared dashboard deserves a second thought. AI-generated summary, reviewed by an editor. [More on our AI guidelines](https://www.implicator.ai/about/). [15 CLI Tools That Make AI-Assisted Coding in the Terminal Actually WorkThe terminal is no longer a fallback interface for developers who refuse to move on. It is the main stage. AI coding agents run there, generate files there, commit code there. The graphical IDE still The Implicator![](https://www.implicator.ai/content/images/2026/03/2026-03-15-05.01.42-terminal_cockpit@2x.webp)](https://www.implicator.ai/15-cli-tools-that-make-ai-assisted-coding-in-the-terminal-actually-work/) [Claude Code, Codex, and Gemini CLI Are Converging. The Gaps Matter MoreClaude Code, Codex CLI, and Gemini CLI now share a core set of terminal-agent patterns as of March 2026, according to documentation from Anthropic, OpenAI, and Google. Commands like /clear, /model, anThe Implicator![](https://www.implicator.ai/content/images/2026/03/2026-03-22-15.47.02-cockpit_switches@2x.webp)](https://www.implicator.ai/claude-code-codex-and-gemini-cli-are-converging-the-gaps-matter-more/) [15 CLI Tools That Make AI-Assisted Coding in the Terminal Actually BearableAI coding agents live in the terminal now. Claude Code, Gemini CLI, Codex, they all run where the cursor blinks. Developers who adopted these tools discovered something uncomfortable last year: the prThe Implicator![](https://www.implicator.ai/content/images/2026/03/2026-03-04-05.34.58-terminal_tools@2x.webp)](https://www.implicator.ai/15-cli-tools-that-make-ai-assisted-coding-in-the-terminal-actually-bearable/)