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

With no annotations, the description carries the burden and does well: 'TypeScript AST, not executed' makes clear this is a side-effect-free static read, and 'Reports whether each value is a literal or a runtime expression' sets expectations for output shape. It omits edge-case behavior such as what happens when no config is found, keeping it short of a 5.

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?

Three tight sentences, front-loaded with the core action and resource, with the static-analysis nature and scope placed where they matter most. Every clause 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?

An output schema exists so return values need no explanation, and the description covers the static-analysis nature, inspected fields, and project-level scope. Only the absence of any failure/no-config behavior keeps it from being fully complete.

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% and both parameters (configPath, projectRoot) are fully documented in the schema, including auto-detection defaults. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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 ('Statically analyze playwright.config.*') and enumerates exactly which settings and reporters it inspects. The scope qualifier 'Project-level, not per-spec' cleanly separates it from per-spec siblings like run_playwright_test.

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 mention of 'flakiness-relevant settings' implies this is a pre-flight diagnostic for flaky tests, but it never says when to reach for this tool versus check_test_prerequisites or score_test_quality. Usage is inferable but not stated.

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 behavioral burden and does so well: it explicitly declares the operation is read-only and that it will NOT install packages or download browsers — the key safety concern for an agent deciding whether the call is side-effect-free. It omits permission/error behavior, but the critical non-mutation trait is disclosed.

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 safety-relevant "Read-only preflight check" is front-loaded, followed by a tight enumeration of detected artifacts. It is a single dense sentence with no filler, though the long detected-item list reads slightly run-on.

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?

An output schema exists, so return values need not be described. The description adequately conveys what the check covers and that it is non-mutating. The remaining gap is the absence of any routing guidance relative to the sibling check_playwright_config.

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 a single optional parameter whose schema description already covers it (100% coverage), auto-detected if omitted. The description references "a target project" but adds no meaning beyond the schema, so the baseline of 3 applies.

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 opens with a precise verb+resource ("Read-only preflight check for a target project") and enumerates exactly what it detects (Playwright package, CLI, config, browser builds, channels, Allure, artifacts). This is far more specific than the bare title, though it never names the closely related sibling check_playwright_config to draw a boundary.

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?

"Preflight check" implies it runs before test execution, giving implied timing guidance. However, it never states when to prefer this over check_playwright_config or what condition should route an agent here versus elsewhere, so guidance remains implicit rather than 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 burden and does well: it discloses that 'allure' writes allure-report/ from allure-results/ using a local CLI that is 'never downloaded', and it enumerates the possible outcome statuses including setup_required, which implicitly warns about missing prerequisites. It does not say whether an existing allure-report is overwritten or what happens on partial generation.

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?

Front-loaded with the core action, then compact per-value clauses and a status list, with no filler. It is dense but every sentence carries information; the status enumeration is slightly terse but 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?

An output schema exists, so return values need not be explained, yet the description still summarizes status outcomes. For a 2-parameter, zero-required tool this is nearly complete; only edge behavior (overwriting existing reports, prerequisite failure handling) is unaddressed.

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% and the reporter enum is fully documented in the schema; the description's per-value explanation largely restates that enum text rather than adding new syntax or constraints. projectRoot is left entirely to the schema. Baseline 3 applies since the schema does the heavy lifting.

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+resource ('Locate or generate a visual test report') and then splits the behavior per reporter value, making the locate-vs-generate distinction explicit. This clearly separates it from siblings like score_test_quality (analysis) and run_playwright_test (execution).

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 gives clear context for which reporter value to choose and what each one does ('quality'/'html' locate, 'allure' generates), which is real routing guidance. However, it never states when to prefer this tool over alternatives such as check_test_prerequisites or score_test_quality, and offers no 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 supplied, so the description must carry the full behavioral burden. It does disclose that the tool reads from a previous run's report and enumerates what is surfaced, but it never states that the operation is read-only/side-effect free, nor what happens when testTitle/testId matches nothing. That leaves meaningful behavioral gaps for a no-annotation 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?

Two sentences, front-loaded with purpose before the conditional-parameter note. The long artifact enumeration is useful for selection but overlaps with the output schema, which slightly dilutes conciseness.

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?

An output schema exists, so the return values need not be explained in prose, and the description still covers the key precondition and the duplicate-title case. Only the absence of read-only/error behavior keeps it from being fully complete for a no-annotation 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 coverage is 100%, so all four parameters including the testId conditional requirement are already documented in the schema. The description's 'Pass testId when titles repeat' restates the schema rather than adding new syntax, format, or defaulting detail, so the baseline 3 applies.

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 ('Get the full diagnostic breakdown for one failing test') and pins the source to a previous run_playwright_test report, which separates it from run_playwright_test and generate_test_report at a glance. The enumerated payload (location, steps, call log, console/page errors, failed requests, artifact paths) makes the scope 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?

Gives a clear precondition (a report from a prior run_playwright_test) and a concrete disambiguation rule ('Pass testId when titles repeat, e.g. the same spec in several projects'). It stops short of naming alternative tools for adjacent needs (e.g. generate_test_report for an overview), so no explicit when-not guidance.

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 real behavior: results are bounded, up to 5 failures are returned, artifact paths and diagnostics come from trace.zip/diagnostics fixture, and the project's own reporters keep running. It does not disclose side effects of executing a test run (process spawn, timeouts, server/runner requirements) or what happens on timeout, and a large share of the text describes the agent's chat response rather than the 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?

Purpose is front-loaded and clear, but roughly half the text is an off-topic 'TOKEN ECONOMY INSTRUCTION' plus a three-option fix-confirmation protocol that describes how the agent should format its reply rather than what the tool does. Those sentences do not earn their place in a tool definition and dilute the signal.

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?

An output schema exists, so return values need not be re-explained, and the description still covers run scope, filtering, timeout, reporting and artifact generation adequately for a 7-parameter tool. The remaining gap is environment/prerequisite context, though sibling tools (check_test_prerequisites, check_playwright_config, set_project_root) partially cover that.

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% with per-parameter descriptions for all 7 parameters, including the detail enum semantics, so the schema does the heavy lifting. The description only echoes the detail:'full' behavior, adding no new parameter meaning. Baseline 3 is appropriate.

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 ('Run a Playwright spec file in the target project') and immediately characterizes the return shape. It differentiates itself from the sibling get_failure_details by naming it as the route for deeper per-test detail. An agent can identify the tool's role without opening the schema.

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?

Routes the agent to two alternatives ('Use detail:'full' or get_failure_details for more'), which is genuine when-to-use guidance. However, it never states prerequisites (e.g., that check_test_prerequisites / project root setup may be needed) or when *not* to run this tool, and the guidance is embedded in a large block of unrelated workflow instructions.

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 well: it discloses exactly which files are generated and that the spec is a non-functional skeleton whose tests are test.fixme (skipped) and tagged @mcp-skeleton until TODOs are implemented. It stops short of stating that files are written to disk by default and how conflicts with existing files behave beyond the schema's overwrite flag.

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?

Front-loaded with the verb and artifact list, then the skeleton caveat, then the usage rule; three sentences with almost no filler. The first sentence is a long comma-run list, which is dense but justified since it defines the tool's scope.

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?

An output schema exists, so return values need not be explained, and the description covers inputs' intent, generated artifacts, and the skipped-skeleton behavior. The remaining gap is prerequisites/ordering relative to sibling tools like check_test_prerequisites.

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 featureName, steps, overwrite, and projectRoot are already fully documented in the schema (including kebab-case/camelCase examples and the steps default). The description adds no parameter-level meaning beyond what the schema provides, which is the baseline 3.

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 (scaffold) and enumerates the exact artifacts produced: pages, mock API handlers, real API helpers, custom fixture, dynamic data factory, a spec, plus a shared diagnostics fixture under tests/e2e/support. No sibling tool creates project scaffolding, so the purpose is unmistakable against run_playwright_test, score_test_quality, or generate_test_report.

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?

"Always use this before writing new tests to ensure a consistent structure" gives explicit when-to-use guidance and a clear ordering constraint relative to test authoring. However, it names no alternatives and states no when-not-to-use condition (e.g., how it relates to check_test_prerequisites).

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 disclose a genuine behavioral trait — TypeScript AST parsing that ignores comments and strings, plus line-numbered warnings — which is more than a bare restatement. However it never states that the operation is read-only (it is not, when generateHtmlReport writes a file) or what prerequisites/configuration it depends on.

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 that front-loads the verb, target, and mechanism before listing the outputs. Dense but every clause earns its place; only the long colon-separated metric list makes it slightly heavy 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?

With full schema coverage and an output schema that carries the return shape, the description only needs to justify the tool's existence and it does so clearly. The one remaining gap is the absence of a stated precondition or relationship to prerequisite/config siblings, which slightly limits an agent's routing confidence.

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 three parameters (specPath, projectRoot, generateHtmlReport) are already documented in the schema, setting the baseline at 3. The description adds no syntax, format, or constraint detail beyond the schema, though its mention of 'imported Page Objects' loosely reinforces that specPath accepts a page object too.

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 (score) and precise resource (a spec file plus its imported Page Objects), then enumerates the exact metrics produced: semantic-vs-raw locator ratio, assertion density, anti-pattern warnings, and scaffold status. This is unmistakably distinct from every sibling (run_playwright_test, generate_test_report, check_test_prerequisites), so no explicit sibling routing is needed.

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 what the tool computes but never states when to reach for it instead of alternatives such as run_playwright_test or generate_test_report, nor any precondition (e.g. a resolved project root, a sibling tool for prerequisites). Usage is only inferable from the purpose itself.

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 says 'explicitly set' but does not disclose whether the setting persists across calls/sessions, whether it overrides auto-discovery, what happens if the path is invalid, or any side effects.

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, front-loaded with the action and followed by the fallback condition. No filler.

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 single-parameter setter with full schema coverage and an output schema, the description covers the essential purpose and trigger. The main remaining gap is behavioral detail (persistence, override semantics) that no structured field supplies.

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% and the sole parameter is documented with type, requirement, and an example path. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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: 'set the target project root directory'. It also scopes the tool as a fallback, which helps separate it from check_playwright_config, though it does not name that sibling 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?

Gives a clear condition for use: fall back to this when playwright.config.* cannot be auto-discovered. It does not spell out when not to use it (e.g., when discovery succeeds) or name the alternative tools, but the trigger context is explicit.

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