Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the full burden. 'Show' reasonably implies a read-only operation and the sentence discloses what information comes back (names, types, constraints), but it says nothing about behavior when the table is absent, permission requirements, or whether system/catalog tables are visible.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler; the essential verb and returned fields come first and nothing is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple single-parameter read tool with no output schema, the description covers the core return content but omits error behavior and the exact identifier form for the one required parameter. Adequate but with clear gaps given the zero schema coverage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There is one required parameter with 0% schema description coverage, so the description must compensate and it does not. 'For a table' gives no guidance on whether the name should be schema-qualified, case-sensitive, or an exact identifier, which is exactly the ambiguity that breaks DB introspection calls.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Show) and resource (column names, types, constraints for a table), which is clearly distinct from db_list_tables (which tables exist) and db_query (run SQL). It doesn't name those siblings explicitly, so differentiation is inferred rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied — an agent can infer this is the introspection step before querying, but there is no stated when-to-use, when-not-to-use, or routing to db_list_tables/db_query for discovery versus execution.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description does disclose that this mutates data, operates on the local database only, and returns affected row count — useful facts. It omits transactional behavior, whether DDL like CREATE TABLE is permanent, permission requirements, and any warning that statements are irreversible.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two dense sentences with the mutation scope front-loaded and the return value second. Nothing redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The return value is stated, which helps against no output schema, but for a destructive write tool with zero annotations and zero schema coverage the description leaves key gaps: parameter binding semantics and the safety profile of DDL statements.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% for both parameters, so the description must carry the load and it does not: it never explains that 'sql' is the statement string or that 'params' are positional bind values. An agent must guess the shape of the params array and its binding order.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (run/write) and resource (local database) and enumerates the statement types covered (INSERT/UPDATE/DELETE/CREATE TABLE). The 'write statement' framing implicitly separates it from the read-oriented db_query sibling, though it never names that tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The word 'write' implies reads belong to db_query, but the description never states when to use db_execute versus db_query or db_upsert_project, nor any exclusions. Usage is inferable but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden, yet it never states that this is a read-only operation, whether views/indexes are included in "all tables", or how results are shaped/ordered. For a low-risk listing call that is tolerable, but the disclosure gap is real.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler; nothing is redundant and the scope qualifier is included rather than buried.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema and no annotations, so the description is the only source of behavioral detail, and it omits return shape and what counts as a table. Adequate to select and call the tool, but thin for a discovery primitive other DB tools depend on.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is no per-parameter semantics to explain and the description correctly spends no words on them. Baseline 4 applies for a parameterless tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("List all tables") scoped to "the local SQLite database", which distinguishes it from the github_list_* siblings and from db_describe_table/db_query. It stops short of explicitly contrasting with those DB siblings, but the resource itself is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent must infer that this is the discovery step before db_describe_table or db_query. No explicit when-to-use, prerequisites, or named alternatives are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does disclose the key safety trait: read-only, limited to SELECT/WITH/EXPLAIN, returning rows. It does not mention permissions, timeouts, cost/rate limits, error behavior, or whether the limit applies to returned rows versus scanned rows.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence, front-loaded with the verb and read-only constraint, with no wasted words. The parenthetical statement-type restriction is compact and useful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the core operation, safety restriction, and return shape at a high level, which is adequate for a read-only query tool. However, with no annotations, no output schema, and zero schema description coverage, the missing parameter semantics for 'limit' and 'params' leave clear gaps an agent would need to guess.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, but it only vaguely implies the 'sql' parameter. It says nothing about 'limit' (including its default of 200 and max of 1000) or about 'params' as bound values, leaving two of three parameters undocumented anywhere.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource ('Run a read-only SQL query ... against the local database') and states the return ('return the rows'). The read-only restriction also distinguishes it from the sibling db_execute, which handles writes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It clearly scopes when this tool applies by restricting allowed statements to SELECT/WITH/EXPLAIN, which implicitly excludes writes and routes them elsewhere. It does not explicitly name db_execute or db_list_tables as alternatives, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full behavioral burden. It identifies this as an upsert mutation, but it does not explain overwrite semantics, whether omitted columns are preserved or cleared, permission requirements, conflict behavior, or what the operation returns.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence with the key operation and resource front-loaded. There is no unnecessary text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too sparse. It omits important upsert behavior, parameter details, and result expectations that an agent would need before invoking it safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description should compensate, but it only mentions the unique project name. It does not describe the roles of `notes` or `repoFullName`, nor does it clarify that `name` is required and the others are optional.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific operation and resource: insert or update a row in the `projects` table, keyed by unique project name. It is clearer than a generic database mutation, though it does not explicitly contrast itself with `db_execute` or `db_query`.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'Convenience helper' and the table-specific behavior imply when the tool should be used: for upserting project rows by name. However, it does not explicitly say when to use this instead of `db_execute`, `db_query`, or other database tools, nor does it state exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden, yet it only implies a write operation. It says nothing about required permissions, whether creating an issue triggers notifications or webhooks, what happens with duplicate titles, or what the response contains.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short sentence, front-loaded with the action. It is efficient with no wasted clauses, though its brevity here reflects under-specification rather than disciplined economy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with zero annotation coverage, no output schema, and 0% parameter documentation, the description is far too thin. An agent cannot confirm auth requirements, required fields beyond the schema's single 'required' entry, or what is returned on success.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% across 5 parameters. The description only obliquely covers repo/owner via 'in a GitHub repository' and says nothing about title being required, the role of body, or label semantics and format (names vs IDs). Four of five parameters remain undocumented in both schema and description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Create a new issue in a GitHub repository.' An agent can distinguish this from the sibling read tools (github_list_issues, github_list_pull_requests) by the verb alone, though the description never names an alternative explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this instead of github_list_issues or other siblings, and states no prerequisites such as authentication, required scopes, or whether the target repository must already exist. The agent must infer all preconditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description still conveys that this is a read operation returning file contents, which is minimally sufficient. However, it omits authentication requirements, rate limits, error behavior for missing files, encoding/size limits, and does not describe the response structure (there is no output schema).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

It is a single front-loaded sentence with zero wasted words. The verb and resource appear immediately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a four-parameter tool with no annotations and no output schema, one sentence is too thin. It does not explain how owner/repo are provided, does not describe the return value beyond 'contents,' and leaves auth/error behavior unstated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50%, with repo and owner undocumented in both schema and description. The description only vaguely references 'at a given ref' and does not clarify how owner/repo are supplied or add meaning beyond the schema's own path/ref descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb ('Read') and resource ('file's contents from a GitHub repository at a given ref'), making the core action clear. It is distinguishable from siblings like github_list_directory and github_search_code by outcome, though it does not explicitly name alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied: call this when you know the file path and want its contents. There is no explicit when-to-use/when-not guidance, and no mention of using github_list_directory to discover paths or github_search_code to locate files.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden and largely drops it: nothing about token/auth requirements for private repos, rate limits, result truncation (GitHub caps large directories), or how entries are ordered. Only 'List' hints at a read-only operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler, mapping directly to verb and scope. It is efficient, though its brevity edges into under-specification rather than pure concision.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With four parameters at 25% coverage, no annotations, and no output schema, the description should explain what is returned (entry names only vs. type/size/SHA) and how owner/repo/ref combine. None of that is present, so an agent knows the purpose but not the contract.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 25% — just 'path' is documented. 'owner', 'repo', and especially 'ref' (branch/tag/commit selector) are unexplained in both schema and description, and the description does not compensate; it only vaguely gestures at 'a GitHub repository' and 'a given path'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('List') and resource ('files and subdirectories at a given path in a GitHub repository'), which is enough to separate it from github_get_file (single file) and github_list_repos (repos, not contents). It stops short of naming those siblings explicitly, so it is clear but not maximally differentiated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description never says when to use this versus github_get_file, github_search_code, or a recursive listing, and offers no prerequisites (auth, private repo access). Usage is only inferable from the verb 'List', which is the same bar as the MID calibration example.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does not disclose pagination behavior, whether results are sorted, authentication needs, rate limits, or what a listing returns — all important for a read/list tool with 0% annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single efficient sentence with no filler, front-loading the resource and optional filter. Slightly under-specified rather than overly concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations, no output schema, and 0% parameter coverage across four parameters, the description is too thin. An agent lacks pagination, auth, and result-shape context needed to invoke it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate, but it only alludes to repo and state filtering. It says nothing about owner or perPage (the pagination cap of 100, defaults), leaving half the parameters unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: 'List issues for a repository'. Clear what it does and that filtering is optional. It doesn't explicitly differentiate from siblings like github_list_pull_requests, but list vs create is obvious.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'optionally filtered by state' implies usage context, but there is no explicit when-to-use guidance, no mention of the alternative github_create_issue, and no note about pagination or result limits when listing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are supplied, so the description carries the full burden and largely drops it. It does not state that this is a read-only operation, whether private repos require authentication, how pagination behaves (perPage is oddly required), or what the response looks like. For a zero-annotation tool, that is a substantial gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler; the resource and the filter qualifier both arrive immediately. Nothing in it is padding, though the small size is in tension with the thin coverage elsewhere.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations, no output schema, and 0% schema description coverage, this definition leaves an agent without permissions context, return-shape expectations, or pagination semantics. Given that two of four parameters are required, the description should have done considerably more.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% across four parameters, so the description must compensate and barely does. It implies a repo identifier and a state filter, but never explains the owner/repo split, perPage paging, or the enum values — and it calls state "optional" while the schema marks it required, which is actively misleading.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("List pull requests for a repository") with a scoping qualifier, which is enough to distinguish it from siblings like github_list_issues and github_list_repos by resource type. It stops short of 5 because the scope is thin — no mention of pagination limits, sort order, or what the listing contains.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use or when-not-to-use guidance and no named alternatives. The only hint is "optionally filtered by state," but with no guidance on defaults, pagination strategy, or when to use this versus other GitHub listing tools, the agent must infer everything.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full behavioral burden. It usefully discloses the auth-dependent visibility scope (own repos plus visible orgs), but omits pagination behavior, ordering, error handling, and whether results are read-only.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with zero waste. The scope is stated immediately and nothing is repeated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple two-parameter list tool, the description covers the high-level scope but leaves gaps around pagination, per-page behavior, and return shape. It is adequate to begin a call but not fully complete without annotations or an output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 50%: the `type` parameter has a schema description, but `perPage` does not. The tool description adds no parameter-level meaning beyond the schema and does not explain how `perPage` controls pagination or how the parenthetical scope maps to `type`.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('List repositories') plus an explicit scope ('visible to the authenticated GitHub token'). The sibling tools operate on files, directories, issues, pull requests, search, or database objects, so an agent can immediately distinguish this tool's purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use it by naming the token-scoped repo listing, but it does not give explicit when-to-use/when-not-to-use guidance or name any alternative tool. Usage is inferable but not spelled out.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It says nothing about authentication requirements, rate limits (GitHub code search is heavily throttled), pagination, or the 50-item cap on results — all things an agent needs before calling a code search endpoint.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence, front-loaded with the action and resource, with the parenthetical scope qualifier in the right place. Nothing is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an unannotated tool with no output schema and only 25% parameter coverage, the description is too thin: it omits auth/rate-limit behavior, result-cap semantics, and the meaning of half the parameters. An agent could invoke it but could not predict its behavior or cost.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 25%: just `query` is documented, while `repo`, `owner`, and `perPage` have no explanation in either schema or description. The phrase 'or scoped to one repo' gestures at the `repo` parameter but does not clarify how `owner` and `repo` interact or what `owner` alone does.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Search code across GitHub', with an explicit scope option (org-wide vs single repo). It is clearly distinguishable from siblings like github_get_file or github_list_directory, though the description never names an alternative for the case where the file path is already known.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage by referencing GitHub's code search syntax, but it gives no explicit when-to-use guidance, no condition for choosing this over github_get_file, and no note about prerequisites such as authentication for code search.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.