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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the tool's purpose and does not describe side effects, whether it modifies anything, performance implications, or what 'size thresholds' means by default. For a read-only scanning tool, this is a notable 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?

The description is concise, using two short sentences with no redundancy. It front-loads the core function and includes a brief usage tip. This is efficient, though it sacrifices depth for brevity.

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?

Despite having 9 parameters and no output schema, the description fails to explain return formats, default thresholds, recursion behavior, or how filters interact. An agent would likely need to experiment or inspect sibling tools to fully understand the output. The lack of behavioral details makes it incomplete for a complex scanning tool.

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 100%, so the schema already documents all 9 parameters. The description adds value by hinting at the 'limit' parameter's role in controlling output, but it does not elaborate on other parameters like max_depth, extensions, or ignore_patterns. The baseline of 3 is appropriate given the schema's thoroughness.

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 verb ('finds') and resource ('files/functions') with a condition ('exceeding size thresholds'), making the core purpose clear. However, it does not differentiate from sibling tools like get_line_counts or get_code_smells, which might also involve size or threshold analysis. The clarity is adequate but not exemplary.

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 offers minimal usage guidance: 'Use limit to control output.' It does not explain when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. An agent would need to infer the intended use case from the tool name and schema alone.

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 discloses a meaningful behavioral nuance—that dead_code is proven unreachable while unreferenced_exports may be used outside the scan—but it does not address other aspects like read-only nature, side effects, performance, or result format. The coverage is minimal.

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 sentences with zero wasted words. The core purpose is front-loaded, and the second sentence clarifies the output categories. Highly efficient and well-structured.

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 output schema and no annotations, the description leaves important context missing: what the results look like (e.g., file paths, symbol names), how limit and depth interact, and whether the scan is read-only. The description is too sparse for a 7-parameter tool without 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 100%, meaning all 7 parameters are documented in the schema. The description adds no parameter-specific details beyond that. Baseline 3 is appropriate because the schema handles parameter semantics.

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 clearly states the tool's purpose: finding declared symbols that nothing references. It specifies the resource (declared symbols) and the action (finds unreferenced ones). It also adds nuance by distinguishing dead_code from unreferenced_exports, but it does not explicitly differentiate from sibling tools like get_code_smells or get_code_inventory, so it falls short of a 5.

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?

There is no guidance on when to use this tool versus the alternative code-analysis siblings. The description does not mention any exclusions, alternatives, or context that would help an agent decide between find_dead_code and other similar tools. This is a clear gap.

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 of behavioral disclosure. 'Lists' implies a read-only operation, but the description does not state whether the operation is safe, how it handles large codebases, or what the response structure is. It also does not disclose potential performance implications or the meaning of 'extensions' beyond a vague filter hint.

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 two short sentences, front-loading the primary action and then giving a filtering hint. It is concise with no filler. However, it could be slightly more structured to include usage context, but as-is it is efficient.

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 9 parameters, no output schema, and no annotations, the description is insufficiently complete. It does not explain what the output looks like, how results are ordered, or any default behaviors. It also does not provide guidance on when to use this vs. more specific tools like get_functions, leaving an agent to infer the tool's role. This is a significant gap for a complex inventory tool.

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 100%, so all parameters already have descriptions. The tool description adds only a minor hint about using extensions to filter, which slightly reinforces the extension parameter but does not add substantive meaning beyond the schema. The baseline of 3 is appropriate because the schema handles parameter semantics fully.

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 verb 'lists' and identifies the resource as classes, functions, methods, and exports. It clearly indicates the tool produces an inventory of code symbols. However, it does not explicitly distinguish from siblings like get_functions, which might lead to ambiguity, but the broad scope is reasonably clear.

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 only says 'Use extensions to filter,' which is a usage hint for filtering but not guidance on when to choose this tool over alternatives. It does not mention when not to use it or compare to siblings like get_functions or get_code_smells. No context about the appropriate scenario is provided.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says the tool 'Finds...' and gives no details on traversal, default scope, whether hidden/ignored files are included, or what the result shape is. 'Finds' weakly implies a read-only scan, but that is not made explicit.

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 compact sentence with no filler; the core artifact types are front-loaded before the location phrase. It earns its place even though more behavioral detail is missing.

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 9-parameter scan tool with no output schema and no annotations, the description is too thin: it omits return format, default limit/depth behavior, and guidance on selecting between this and find_dead_code or get_complexity_metrics. The schema documents parameters but nothing about result semantics.

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 100%, so the schema already documents every parameter. The description's mention of TODO/FIXME markers doubles the 'types' enum, adding marginal semantic color but no new syntax, defaults, or constraints.

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+resource ('Finds ... markers and unsafe casts in code') and enumerates concrete artifact types (TODO/FIXME/HACK/BUG, unsafe casts). This clearly differentiates it from sibling analysis tools like get_line_counts, find_dead_code, and get_complexity_metrics.

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 guidance, no exclusions, and no mention of alternatives among the sibling tools. An agent must infer that this is for code-quality inspection rather than, say, dead code or complexity analysis.

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 fully disclose behavior. It only states that metrics are returned and lists the types, but does not mention read-only nature, directory scanning behavior, potential performance implications, or error handling. The agent gets no sense of side effects or constraints beyond the return value, which is insufficient for a complex analysis tool.

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, compact sentence that front-loads the primary purpose and lists the metric types. There is no filler or repetition. It could be improved with a short usage note, but as is, it is efficiently written and easy to parse.

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 tool has 8 parameters but the description does not explain the return structure, default limits, or how the metrics are aggregated (per-function vs overall). The metric list helps, but without an output schema or explicit behavioral notes, an agent may not know whether results are a list, map, or include counts. The description covers the essentials but leaves gaps for a complex tool.

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 100%, so the baseline is 3. The description adds a minor hint about using limit and summary_only to control output, which is slightly redundant with the schema's own descriptions ('Max results', 'Summary only'). It does not provide deeper semantics like default values or interaction between parameters, so it stays at baseline.

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 clearly states the tool returns complexity metrics and enumerates specific metric types (nesting, params, cognitive, per-function cyclomatic), which provides a clear verb+resource. However, it does not explicitly differentiate from sibling tools like get_code_smells or check_thresholds, so it misses the sibling-distinguishing element for a 5.

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 includes a parameter tip ('Use limit/summary_only to control output') but offers no guidance on when to use this tool versus alternatives. There is no statement of conditions for use, no exclusions, and no mention of other tools. This falls short of even clear context, let alone explicit alternatives.

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 of disclosing behavior. 'Finds' implies a read-only scan, but the description does not explain what counts as undocumented, what the output looks like, whether hidden files are included by default, or any side effects. This is a significant gap for a scanning tool with nine parameters.

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 two short sentences with no filler. It front-loads the core purpose and then directs attention to the most relevant output-control parameters, making it efficient and easy to parse.

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?

Given the tool's complexity nine parameters, no output schema, and no annotations, the description is too sparse. An agent would not know what the result format is, what the default behavior is, which parameters are optional in practice, or what criteria define 'undocumented'. The description does not compensate for the missing structured metadata.

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 100%, so the schema already documents all parameters, meeting the baseline of 3. The description adds minimal added value by pointing to limit and summary_only as output controls, but it does not explain their semantics beyond what the schema already provides.

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 action ('Finds undocumented functions/classes') and identifies the tool's core purpose, which is clear and distinct from siblings like get_functions or find_dead_code. However, it does not explicitly differentiate itself from sibling tools by naming alternatives or contrasting scopes, so it falls just short of a 5.

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 provides no guidance on when to use this tool versus alternatives like get_documentation_coverage, get_code_inventory, or find_dead_code. It only mentions limit/summary_only for controlling output, which is parameter-level advice, not usage context.

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 provided, the description carries the behavioral burden. It conveys that this is a read-style operation ('Returns') and reveals one mode of behavior (detail=lines). However, it does not disclose scanning behavior, defaults, or what counts vs. lines actually means beyond the brief hint.

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 short sentences, no filler. The main purpose is front-loaded and the parameter tip is direct. Every word earns its place.

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 11-parameter tool with no output schema and no annotations, the description is minimally adequate. The schema documents all parameters, and the description adds one useful detail-mode hint. However, it does not clarify the default behavior, what 'info' includes, or how it relates to sibling tools like get_line_counts.

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 100%, so the baseline is 3. The description adds value by explaining that detail=lines yields 'line counts per function,' which is more meaningful than the schema's bare 'Detail level.' That semantic clarification justifies above-baseline scoring.

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 clear verb and resource: it 'Returns function/method info,' which is genuinely informative. It does not explicitly differentiate from siblings like get_line_counts or get_code_inventory, so it misses the top score, but the core purpose 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?

'Use detail=lines for line counts per function' gives a concrete usage instruction for a parameter, implying a use case. However, it does not say when to choose this tool over the closely related sibling get_line_counts, nor does it mention any exclusions or alternatives.

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 of behavioral disclosure. The description only states the return type (line counts) and a filtering hint. It does not disclose whether the operation is read-only, whether it scans recursively, how hidden files are handled by default, or any performance implications. For a tool with 7 parameters, this is a significant 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?

The description is two short sentences with no wasted words. The core purpose is front-loaded. It is concise, though it could add a bit more behavioral context without becoming bloated.

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?

Given 7 parameters, no annotations, and no output schema, the description is too thin. It does not explain return value structure, default behaviors (e.g., whether hidden files are included by default), or how filters interact. An agent would need to inspect the schema carefully and still might not know when to choose this over sibling tools.

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 100%, so the schema already documents all parameters. The description adds minimal value beyond the schema, only mentioning extensions as a filter. Baseline 3 is appropriate because the schema does the heavy lifting, but the description does not clarify relationships between parameters (e.g., grep vs ignore_patterns) or default behavior.

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 verb and resource: 'Returns file line counts (code/blank/comment).' This clearly identifies what the tool does. It does not explicitly differentiate from siblings, but the resource (line counts) is distinct enough among the listed siblings.

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 a brief usage hint: 'Use extensions to filter.' This implies the tool is for counting lines and can be filtered, but it does not explicitly state when to use this tool versus alternatives like get_code_inventory or get_complexity_metrics. No exclusions or alternative routing is provided.

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 burden of explaining behavior. It discloses the core heuristic approach ('finding parameter names passed through chains of functions'), which is useful. However, it does not explain return format, whether results are summary + per-parameter details, false-positive risks, or what 'prop drilling' detection entails in practice.

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 sentences with no filler. The first sentence states purpose and mechanism; the second quickly points to the key output controls. Every sentence earns its place and the core information is front-loaded.

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 tool has 10 parameters and no output schema, and there are no annotations to fill gaps. The description does not explain what the output looks like, how chains are defined, what summary-only mode returns, or which fields like max_depth, max_files, and include_hidden affect results in practice.

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 100%, so the schema already documents all 10 parameters. The description adds only a minor hint by naming limit and summary_only as output controls, but this does not meaningfully improve on the existing parameter 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 uses a specific verb ('Detects') and a clear resource ('parameter threading (prop drilling)'), and it explains the mechanism ('finding parameter names passed through chains of functions'). This distinguishes it from sibling tools like get_line_counts or get_functions, even without naming an alternative.

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 says 'Use limit/summary_only to control output' but gives no guidance on when to use this tool versus alternatives such as get_code_smells or find_dead_code. There is no statement of when-not-to-use, and no explicit differentiation from sibling analysis tools.

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