Nasaq UI

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

With readOnlyHint already declaring a safe read, the description adds genuine context: default include is readme, `name` resolves against folders, titles or exports, and `framework` swaps the stack. It omits failure behavior (e.g., what happens when a name matches nothing), which is the main remaining 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?

Three dense sentences, front-loaded with the purpose, then parameter mechanics in a sensible order. Very little waste, though the framework list reads as a compressed enumeration that borders on reference material.

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?

No output schema exists, so the description carries the return-value burden; it explains that include selects what comes back (readme, api, examples, source, story, all). Missing unsupported-name handling and pagination/size expectations, but complete enough for correct invocation.

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 67% and the `name` parameter has no documentation in the schema at all; the description fills that with the folder/title/export resolution rule and clarifies the meaning of each framework target. This adds real meaning beyond the enum lists, though framework default behavior is only sketched.

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 ('Returns one component's details and manual') and scopes it to a single component, which implicitly separates it from list_components and search_components. It does not, however, explicitly name which sibling to use for listing/searching, so the 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?

The description is rich on how to call the tool (name forms, include modes, framework targets) but never says when to reach for get_component versus search_components or list_components. Usage is implied by the 'one component' framing rather than guided.

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?

Annotations already declare readOnlyHint=true, so safety is covered. The description adds one genuine behavioral trait — that omitting `topic` switches the call into a topic-listing mode — but says nothing about output format, whether topics must match the listed categories, or failure behavior for unknown topics.

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 tight sentences with the content scope front-loaded and the parameter hint trailing. Efficient, though the enumerated topic list reads slightly like a payload dump rather than a purpose statement.

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?

No output schema exists, yet the description covers what kinds of documents come back at a high level. For a one-optional-param read tool that is barely enough; topic validity and return format remain unspecified, and siblings are not disambiguated.

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% and the single `topic` param has no description, so the description must compensate. It does partially, by explaining the omit-to-list behavior, but it never states valid topic values, casing, or format despite enumerating plausible topic names in prose.

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 identifies what the tool returns — the design rules behind the components (colour roles, layout/density, architecture, brand rules, README spec) — which tells an agent this is the foundations/documentation resource. However, it never names or contrasts with siblings like get_component or get_setup, so the agent must infer the split from names alone.

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?

Aside from a parameter-behavior note ('Omit `topic` to list topics'), there is no statement of when to reach for this tool instead of get_component, get_setup, or list_tokens. The implied use case (fetch design foundation docs) is left for the agent to infer.

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?

readOnlyHint=true already tells the agent this is a safe, non-mutating read, so the description's remaining job is to disclose the return shape, which it does at a high level (install command, CSS imports, provider). It adds the 'call once' hint, implying the guide is stable and need not be re-fetched, but says nothing about output format, size, or whether the guide is code or prose.

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 plus a compact parameter clause; the output contents are front-loaded before the usage rule and the parameter explanation. Dense and largely waste-free, though the trailing framework list is redundant with the enum it sits next to.

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 read-only, zero-required-param guide tool with no output schema, the description covers what is returned and when to call it. What remains unstated — the exact response shape and whether the guide is code vs. prose — is modest, and the annotation already carries the safety profile.

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 enum values are already fully documented in the schema, making 3 the baseline. The description's inline list is actually narrower than the schema enum — it omits 'nuxt' and 'inertia-vue' and collapses inertia-vue into 'vue' — so it adds little and slightly under-represents the real options.

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 the concrete payload it returns (install command, CSS imports, provider, app skeleton), which is far more specific than the title's 'how to install and set up'. It implicitly distinguishes itself from the component/token siblings (get_component, list_tokens, search_components) by being the scaffolding guide, though it never names them.

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 imperative 'Call once before building UI' gives explicit timing guidance that no sibling tool provides, telling the agent this is a prerequisite step rather than a lookup. It stops short of naming an alternative or a when-not-to-use condition, but the sequencing instruction is clear and actionable.

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 readOnlyHint=true already covering the safety profile, the description adds genuine value by disclosing the result shape (category, status, summary, exports) and the notable behavior that a non-React framework narrows results to components that actually exist in that stack. It does not mention pagination or result limits, but the core behavioral traits are covered.

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, zero filler, with the core action and returned fields front-loaded and the framework caveat last. Every sentence carries distinct information.

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 the description compensates by naming the returned fields, so an agent knows what it gets back. It is close to complete for a read-only list tool, with only pagination/ordering behavior left 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 description coverage is 100% and the framework enum is exhaustively documented in the schema itself, so the baseline is 3. The description restates the category/query filters and the framework restriction without adding format, default, or combination 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?

States a specific verb (Lists) and resource (Nasaq web components) and enumerates the returned fields (category, status, one-line summary, exports), which separates it from get_component's detail view. It does not, however, explicitly contrast itself with the close sibling search_components, so an agent must infer the 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?

Filtering behavior is implied ('Filter by category or a text query') and the framework caveat gives a real usage rule. But there is no guidance on when to prefer this over search_components or get_component, nor any stated prerequisite or exclusion.

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?

The readOnlyHint annotation already establishes the safe-read profile, so the description's added value is the return shape: each token carries a value per context (light, dark, brand, density). That is genuinely useful output context, but it says nothing about default result size, pagination, or behavior when no prefix is supplied.

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 short sentences with no filler, front-loaded with the resource being returned. The filtering example and the Tailwind utility mapping each earn their 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 a read-only list tool with no output schema and two undocumented parameters, the description covers the resource, its multi-context values, and prefix filtering reasonably well. It still leaves the limit/pagination behavior and the no-filter default completely 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 description coverage is 0%, so the description must carry the parameter burden. It explains 'prefix' with concrete examples ('--nq-danger' or 'surface'), which usefully reveals that both full custom-property names and bare words match, but it never mentions the 'limit' parameter or its maximum of 500.

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 identifies the resource precisely: 'CSS custom properties (--nq-*) with their value in each context (light, dark, brand, density)'. This clearly separates it from component-oriented siblings like get_component and list_components, though it never states the act of listing or enumerating and relies on the tool name for that verb.

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 statement of when to call this tool versus alternatives such as get_foundation or get_setup, and no prerequisites or exclusions. The Tailwind sentence describes what to do with the returned values, not when the tool itself should be invoked.

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?

readOnlyHint=true already covers the safety profile, so the description's remaining job is to add behavior. It usefully discloses that results come back relevance-ranked rather than in a fixed order, which matters for interpreting output. It stops short of saying how many results come back or how ranking is determined.

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?

One sentence, front-loaded with the verb and resource, and the three examples directly disambiguate the expected query style. 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 two-parameter search tool with no output schema, the description covers the query intent but says nothing about the result shape (e.g. component objects with scores) or the limit semantics/default. Adequate but with clear gaps for an agent deciding how to call it.

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 carry the load. It does explain the query parameter well ('a need described in words') with concrete examples, which is real added meaning over the bare string schema. The limit parameter (1-30) is left entirely unexplained, leaving a compensating gap.

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 ('Ranks') plus the resource ('components') and clarifies the input is a natural-language need, which distinguishes it from a plain enumeration like list_components. It does not name a sibling explicitly, so sibling differentiation is implied 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?

The examples ('switch between products', 'empty state') imply this is for fuzzy, intent-based lookup rather than exact IDs, and usage is inferable from the verb 'ranks'. However, there is no explicit when-to-use vs list_components/get_component guidance and no stated exclusions.

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