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

With no annotations, the description carries the full behavioral burden and does reasonably well: it discloses the conditional output (markup only when required inputs are supplied, otherwise fill-in guidance) and enumerates the returned artifacts. Missing permissions, rate limits, or error semantics, but the core conditional behavior is clearly stated.

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 sentences, front-loaded with what is returned, then the guarantees, then the fallback behavior. No filler, though the middle sentence bundles three distinct outputs into one long clause.

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, so the description properly explains the return payload (markup, KWCAG coverage, required inputs, post-assembly checks). Combined with a 100%-documented schema and a nested inputs object, an agent has enough to invoke it correctly, though sibling routing remains unspecified.

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 componentId, variant, and the nested inputs object in detail. The description's mention of mandatory user-supplied values mirrors the inputs parameter concept but adds no format or syntax detail beyond what the schema provides, 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?

The description states a specific verb and resource: it returns the kit markup and accessibility requirements for a KRDS component, plus the KWCAG items it guarantees. An agent can tell this fetches a single component's definition, but the description never names or distinguishes itself from siblings like list_components or get_requirements.

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 by the discussed return content and the note that missing required inputs yields guidance instead of markup, but there is no explicit when-to-use statement nor any comparison against list_components, get_requirements, or validate_page. The agent must infer the correct entry point on its own.

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 and does so well: it names the root cause (kit JS initializes once on DOMContentLoaded and is unaware of client routing) and characterizes the return as conflict diagnoses plus field-verified prescriptions. It doesn't restate read-only safety, but 'get_...guide' plus the content description make the operation type evident.

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 tightly written sentences with no filler, and the failure scenario is front-loaded before the directive. Slightly dense but 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?

For a single optional-enum, no-output-schema guide tool, the description covers what it returns (conflicts + prescriptions) and when to reach for it. Return-value detail is general rather than structured, but adequate given the tool's simplicity.

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% and the enum values (react/nextjs) are documented in the schema, including the empty-value behavior. The description only echoes the React/Next.js scope, adding no new parameter semantics beyond the schema.

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 ('returns conflicts and verified prescriptions for the kit in React·Next.js') and names the concrete symptoms (tabs, accordion, GNB failing in SPA), which is clearly distinct from the component-listing siblings. No explicit sibling comparison, but the 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?

Gives a clear trigger condition ('if kit widgets don't work in SPA') and a strong directive to consult it before inventing a workaround. It lacks a named alternative tool, but the when-to-use context is 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 it delivers: it names the underlying bug, its magnitude (206 locations), the scope of the fix (whole page), and the intended artifact (save as a correction file). It stops short of describing the returned CSS structure or any size/authoring caveats, keeping it shy 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?

Front-loads what the tool returns, then the exclusion, then the use case. Three tight sentences with no filler, though the bug details in the opening clause are somewhat dense.

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 optional-parameter tool with no output schema, the description explains what is produced (corrective CSS), corrects a common misuse path, and specifies the intended action. Complete enough for correct invocation, with only minor gaps around the returned payload's form.

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 assetBase is already documented in the schema (default node_modules/krds-uiux). The description only alludes to the kit asset context and adds no new format or behavior detail for the parameter, 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 concrete verb+resource (returns CSS that corrects the kit v1.1.0 icon path bug img/img duplication, 206 places 404) with precise scope. It explicitly distinguishes itself from the sibling get_page_scaffold, noting that tool already injects this CSS, so an agent can route correctly without opening either 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?

Gives an explicit when-not (if you use get_page_scaffold withSiteChrome it is auto-injected, so not needed) and a when (projects composing layout directly, e.g. React layouts, when icons don't show). It also tells the agent what to do instead of manual per-instance fixes.

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 disclose key traits: output differs drastically with vs without pattern, pattern templates come with accessibility corrections already applied, and missing required slots produce guidance rather than content. It does not state side-effect/idempotency profile or the exact return shape, but for a read-only generator the disclosed behavior is substantive.

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?

Four short sentences, front-loaded with the core behavior and then the mandatory rules. Every sentence carries a distinct instruction (what it returns, pattern vs no pattern, ordering vs component lookup, compliance rule); 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 13-parameter, nested-object tool with no output schema and no annotations, the description covers purpose, mode selection, and sequencing well. The remaining gap is the concrete return form (HTML string vs parts vs file, and how much the caller must post-process) — the `output` parameter implies it, but the description never states it directly.

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 the baseline is 3; the description earns above baseline by giving 'pattern' real semantic weight — that it switches the tool into official-template mode with accessibility fixes and is mandatory for standard screens. The other dozen parameters (withSiteChrome, siteMenu, slots, output, etc.) are left entirely to the schema, which is adequate given full coverage.

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 the starting skeleton of a KRDS page) and immediately distinguishes the two output modes: pattern specified yields a complete accessible template, omitted yields an empty skeleton. It also positions itself relative to siblings by telling the agent to call it before component lookup, so an agent can tell it apart from get_component/list_components.

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?

Explicit sequencing (call before component lookup when building a new page) and an explicit when-not/alternative path (do not hand-craft layouts; use pattern for standard login/apply screens). Both the trigger and the prohibited behavior are stated, leaving nothing to inference.

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 whole burden. It usefully discloses the payload composition (required inputs, guaranteed items, delegated items, unresolved questions), which is real behavioral context for a read tool. It does not state read-only/idempotency guarantees, behavior on an unknown componentId, or any error/rate-limit characteristics.

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, purpose front-loaded, then return contents, then use case. No filler and no repetition of what the schema already states; every sentence 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?

No output schema exists, so the description takes on the job of describing the return payload and does so explicitly. Together with the fully covered single parameter and the named use cases, it is largely sufficient for a read-only lookup, with only edge-case behavior (invalid id, response format) left unspecified.

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 single componentId is fully documented in the schema (including the 'krds:button' / 'button' accepted formats). The description adds no further parameter semantics, 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?

States a specific verb (조회) and resource (특정 컴포넌트의 접근성 요건), and explicitly scopes out markup ("마크업 없이 ... 요건만"), which implicitly separates it from the markup-bearing get_component sibling. It never names a sibling directly, so it stops short of full differentiation.

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?

"코드 리뷰나 설계 검토에 쓴다" supplies a usable context for when to reach for this tool, but there are no exclusions and no alternatives named (e.g., when to use get_component or list_components instead). Usage is implied rather than directed.

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 exist, so the description carries the full burden, and it delivers real behavioral context: var() references are expanded to concrete values (hex, etc.), contrast/accessibility guarantees are baked into tokens, and a query-less call returns category guidance rather than failing. It omits error/empty-result behavior and pagination, but for a lookup tool this is solid 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?

Three tight sentences, front-loaded with what is retrieved, then the value-resolution behavior, then the usage directive, then the no-param fallback. No filler; every sentence informs a decision or expectation.

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 covers the key gaps: what is returned, that values are resolved, what a query-less call yields, and when to prefer it. The main residual gap is that the shape/format of the returned token list is not described, but this is minor for a simple lookup.

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% (the query param already documents space-separated AND matching with examples), so the baseline is 3. The description goes beyond the schema by explaining what happens when the optional param is omitted (category guidance is returned), which is meaning the schema does not convey.

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 (retrieve kit design tokens — color/spacing/font-size CSS custom properties) and adds the non-obvious behavioral detail that var() references are resolved to real values. The scope is unambiguous next to siblings like get_icon_fix_css or list_components, which cover entirely different resources.

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?

Explicitly tells the agent when to reach for this tool ("if you need colors/sizes in custom CSS") and warns against the alternative of hardcoding arbitrary values, plus notes that tokens carry built-in accessibility (contrast). It stops short of naming a sibling tool as the alternative, but the when/when-not framing is clear.

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 disclosure burden. It does well on what gets read (computed styles and font-application/fallback detection) but says nothing about the cost of rendering a browser page, what happens when a selector matches nothing, or how the results come back.

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 sentences, front-loaded with what is read, then the usage triggers, then the required inputs. The property enumeration is long but informative rather than wasteful; nothing reads as 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?

There is no output schema, so the description partially compensates by listing the style properties it returns. Gaps remain around non-matching selectors, the 20-selector cap, and rendering/time cost, but for a read-only inspection tool this is close to sufficient.

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 url, html, filePath and selectors, making 3 the baseline. The description restates 'url or filePath plus a selector list' but omits the html fallback parameter entirely, so it adds little beyond the schema.

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 pair: it reads computed styles (color, background, font, size, layout, margin, padding, gap) and font-application status from a rendered page. That is precise enough to separate it from get_tokens (token values) and validate_page (assertions), though it never names a 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?

It gives concrete triggering questions ('what color is this element', 'is the font really applied or a system fallback', 'where is it positioned') and an anti-pattern (don't spin up a temporary playwright script). It stops short of an explicit when-not-to-use or a named alternative tool.

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 payload shape: each entry carries id, name, and a count of mandatory accessibility inputs. It does not mention ordering, pagination, or caching, but for a zero-parameter read-only catalog the disclosed return semantics are the material trait.

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, front-loaded with the core action and payload, followed immediately by the cross-reference. No filler or restated name/title.

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, so the description must describe returns, and it does so adequately by enumerating the item fields and noting the accessibility count. It is complete enough to call the tool correctly, missing only secondary details like ordering or total-count guarantees.

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 no parameters, so there is nothing to disambiguate and the baseline of 4 applies. The description correctly implies the call is unconditional, needing no filtering input.

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 ('사용 가능한 KRDS 컴포넌트 43종의 색인을 반환한다') and even quantifies scope (43 items). It explicitly distinguishes itself from the sibling get_component, which handles markup and detailed requirements.

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 names the alternative tool explicitly ('마크업과 상세 요건은 get_component로 조회한다'), giving clear routing between index-level and detail-level queries. It stops short of an explicit when-to-use trigger for the listing itself (e.g. discovery vs. validation workflows), so it is clear but not fully prescriptive.

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 and does so unusually well: it discloses that only part of accessibility is auto-judged, that contrast is measured directly, that manual-check items are reported with their procedures, and that a pass here is not a review pass. It also reinforces that a failed interaction step invalidates the inspection and blocks the gate, which is critical operational context an agent must know before calling.

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 purpose, followed by mechanism, limitation caveat, invocation timing, and input preference — each sentence earns its place. The limitation caveat is dense (stacked em-dash clauses) but not redundant, and the whole definition stays proportionate to an 8-parameter tool.

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 tool with 8 optional parameters, no output schema, and no annotations, the description covers why, when, and with what inputs, plus the crucial 'automation is partial' caveat. What is missing is any statement of what the run returns (violations, screenshots, report layout) and how it relates to inspect_page, but with no output schema the gap is modest.

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 genuine decision rule by recommending url (dev server/deploy) or filePath (local HTML) and explaining that relative-path assets resolve correctly in those modes. This prioritization goes slightly beyond the per-field schema text, though most parameter detail is still schema-supplied rather than description-supplied.

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+resource+standard: re-inspects an assembled/converted page in a real browser against KWCAG 2.2, running axe-core and translating results into the 33 KWCAG items. It also clarifies scope beyond automation ('passing here does not mean passing review'), which separates it from a generic inspection. It never names the closest sibling (inspect_page), so an agent must infer the boundary rather than being told.

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?

Explicit invocation timing is given as a workflow sequence: call after converting templates to a framework, after assembling the page, and after filling content. It also steers input choice (url or filePath recommended, html as last resort) and warns against mutating initial values via temporary builds. No alternative sibling tool is named and no clear exclude case is stated, so it stops 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.