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

No annotations are provided, so the description carries the full disclosure burden. It implies a read ("Retorna") but says nothing about what happens if the domain does not exist, whether the lookup is exact-match or case-sensitive, or any access requirements. For a tool with zero annotation coverage 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?

A single front-loaded sentence with no filler; the verb and lookup key come first. It is efficient, though the extreme brevity is partly a symptom of missing content rather than disciplined compression.

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 spelled out here. For a simple one-parameter read tool the description is minimally sufficient, but it omits error behavior and sibling differentiation that would make selection unambiguous.

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

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

Schema description coverage is 0%, so the description must compensate. "Pelo nome do domínio" tells the agent the lone parameter is the domain name used as the lookup key, which adds modest meaning over the bare schema, but gives no format, examples, or matching rules.

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 ("Retorna") and resource ("o conteúdo de uma skill") and how the skill is identified ("pelo nome do domínio"). Clear on its own, but it does not distinguish itself from the close sibling list_skills, leaving the agent to infer the difference between fetching one skill and listing all of 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?

There is no when-to-use guidance, no exclusions, and no mention of the sibling list_skills as the alternative for discovery. The agent is given no conditions under which this tool is preferred over listing skills.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it adds nothing beyond the listing action. It doesn't state that it's a read-only enumeration, whether results are paginated, or how legacy vs SKILL.md skills are returned together.

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

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

A single front-loaded sentence with no waste. It is terse but not padded, though it could carry slightly more routing context at little cost.

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 there are no parameters to cover. The description is minimal but workable for a simple list tool; the missing piece is sibling routing rather than technical detail.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; baseline 4 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 clear verb+resource ('Lista skills') and narrows the scope to legacy skills and Agent Skills in SKILL.md format. It does not explicitly differentiate from sibling list_specs or get_skill, but the resource and format qualifier make the target 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?

No indication of when to use this versus list_specs or get_skill, and no preconditions or exclusions. The agent must infer the routing from the name 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 behavioral burden, yet it discloses nothing beyond the listing action. Read-only behavior is only implied by the verb, and there is no mention of scope ('legacy' specs), pagination, or which pipeline stage the 'features' belong to.

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

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

A single, front-loaded sentence with no filler or repetition. It is efficient, though its brevity reflects under-specification rather than disciplined trimming.

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 with zero inputs the surface area is small. Still, the agent gets no signal on whether results are filtered, paginated, or scoped to legacy-only specs versus active ones, leaving a real gap in a crowded sibling set.

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

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

The tool takes zero parameters, so there is no parameter semantics to convey; the baseline for a 0-param tool is 4. Nothing in the description contradicts or misrepresents the empty argument 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 ('Lista') and resource ('specs legadas e features do pipeline SDD'), so an agent knows this is a listing operation over SDD-pipeline specs and features. It does not differentiate itself from the many sibling spec tools (validate_spec, spec-status, list_skills), so an agent cannot route confidently between them from the text 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?

There is no when-to-use guidance, no when-not-to-use, and no named alternative among the 15 sibling spec tools. The agent is left to infer that this is the enumeration entry point before inspection/validation tools.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses essentially nothing: not whether this writes an artifact, mutates state, requires the spec to be validated first, or is safe/idempotent. It only restates that two inputs are combined.

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

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

A single short sentence with no padding, so it is concise. But brevity here is under-specification rather than efficiency, and the one clause that could carry meaning ('contexto para o agente') is left undefined.

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, which lowers the bar slightly. Still, for a tool with two required, entirely undocumented parameters, zero annotations, and a cryptic purpose, the description leaves the agent without enough to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It alludes to 'spec legada' and 'skill' but never explains what spec_id or skill_domain accept, whether skill_domain is a fixed vocabulary, or how a legacy spec differs from a normal spec.

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 verb ('Combina'/'combines') and two resources (a legacy spec and a skill) that map onto the required parameters, so the general intent is recoverable. However, 'contexto para o agente' is vague about what is actually produced, and nothing distinguishes it from siblings like validate_spec or get_skill.

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 this tool should be used, what precondition triggers it, or which sibling it replaces. An agent must guess that this is a pre-generation assembly step rather than a validation or retrieval step.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Registra' implies a write/persisted state change, but nothing is said about whether approval is idempotent, whether it unblocks later stages (spec-impl), whether it can be revoked, or what permissions are needed.

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

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

A single efficient sentence with the verb and scope front-loaded and zero filler. It is appropriately sized for a two-parameter tool, though it is also thin enough that conciseness comes partly from under-specification.

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, but this is a state-mutating approval gate with no annotations, 0% parameter documentation, and 15 sibling spec tools. Missing are the stage value vocabulary, prerequisite checks, and the effect of approval on downstream 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 coverage is 0%: neither parameter is documented in the schema. The description partially compensates by enumerating the three values the 'stage' parameter conceptually takes (requirements, design, tasks), but it says nothing about the feature_name parameter or the exact string format the stage field expects.

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 ('Registra aprovação humana explícita') and names the three domains it covers (requisitos, design, tarefas). It does not distinguish itself from siblings like validate_spec, spec-status, or spec-feedback, which all operate on the same artifacts, so an agent must guess among several similar-sounding tools.

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 vs when-not-to-use guidance and no named alternatives. The word 'explícita' hints that this records a deliberate human sign-off rather than an automated check, but the description never says when to call this instead of validate_spec or spec-status, nor what prerequisite state is required.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose how read vs. save mode is triggered (presumably the content parameter), whether saving overwrites an existing design.md, what permissions or approval state is required, or whether the operation is destructive.

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

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

A single short sentence with no filler and the resource plus precondition front-loaded. The brevity is efficient, though it borders on under-specification rather than true 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 return values need not be described, but with 0% schema coverage, no annotations, and an unexplained read/write trigger, the description leaves the agent guessing on the core mechanics of a two-parameter 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 0% for both parameters, so the description must compensate and largely fails. 'design.md' loosely maps to content, but feature_name is never explained and no format, expected values, or null-content semantics are given.

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 resource (design.md) and the two operations (read/save), plus the workflow position (after requirements approval), which separates it from spec-requirements and spec-tasks. It is clear, but the description never explains what determines whether it reads or saves, leaving the dual mode ambiguous.

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 precondition 'depois da aprovação dos requisitos' tells the agent exactly when in the spec workflow this tool applies, implicitly positioning spec-requirements before it and spec-tasks after. It does not, however, state which sibling to use instead when requirements are not yet approved, nor when to prefer reading over saving.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the tool is read-only, whether it writes any artifact, how the 'mode' selection changes behavior, or what the generated report depends on beyond the feature name.

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 single sentence is efficient and front-loaded with the verb and outcome, with no filler. But its brevity is under-specification rather than genuine conciseness, since key parameter and routing information is absent.

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. Still, with three parameters at 0% schema coverage and an ambiguous overlap with sibling tools, the description leaves too much unspecified for an agent to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It hints that two output types exist (report vs. gap analysis) but never names the mode parameter or its accepted values, and says nothing about what feature_name or implementation_summary should contain.

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 concrete verb ("Gera") and two possible outputs (status report or gap analysis of the workflow), so the general purpose is discernible. However, it does not distinguish this tool from siblings spec-status and validate-gap, which appear to cover exactly those two functions, leaving the agent unsure which tool to pick.

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 use this tool versus validate-gap (gap analysis) or spec-status (status), nor any prerequisite or context for invoking it. The agent is left to guess based on the ambiguous description 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 behavioral burden. It hints that the tool prepares context while the agent implements, but it does not disclose side effects, permissions, file writes, or whether the operation is read-only or destructive.

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 with no wasted words, and the core action is front-loaded. The semicolon-separated second clause adds slight ambiguity but does not bloat the text.

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

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

An output schema exists, so return values need not be described. Still, with no annotations, 0% schema description coverage, one required parameter undocumented, and no usage context, the description is too thin for an agent to confidently invoke the 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 0%, so the description must compensate. It mentions 'tarefas' in passing, which loosely maps to the optional tasks parameter, but it never explains feature_name (the required parameter), nor does it clarify format, expected values, or the relationship between the two parameters.

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 says it prepares TDD context for approved tasks, which is more specific than restating the name, and it distinguishes the tool from the agent's subsequent implementation. However, the second clause ('o agente implementa no repositório') blurs the tool's own purpose and does not clearly delimit it from siblings like spec-tasks or prepare_generation_context.

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 'tarefas aprovadas', suggesting this tool should be invoked after approval. But there is no explicit when-to-use statement, no when-not guidance, and no named alternatives among the many sibling tools.

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 the concrete side effect of creating a requirements.md draft, which is useful, but it says nothing about prerequisites, whether existing files are overwritten, or where the draft is written.

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

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

A single front-loaded sentence with zero filler. It is efficient, though its brevity tips into under-specification rather than tight information design.

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, but with no annotations, 0% parameter documentation, and no usage context, the definition is too thin for a tool that mutates the filesystem and anchors a multi-step spec workflow.

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% and the description explains neither parameter. 'feature' loosely gestures at feature_name, but project_description (the required parameter) is entirely unexplained in both the schema and the description, leaving the agent to guess its expected content and scope.

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 (initializes) and resource (a feature), plus the concrete artifact produced (requirements.md draft). It is clear enough to act on, but it does not distinguish itself from close siblings such as spec-requirements, which likely also touches requirements.md.

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 when-to-use guidance and no mention of the alternatives in the sibling set (spec-requirements, prepare_generation_context). An agent must infer that this is the entry point of the spec workflow purely from the name.

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. It does disclose one genuinely important behavioral trait - that re-saving removes downstream approvals, a destructive side effect. Beyond that warning it says nothing about permissions, reversibility, or state, but no return format is needed since an output schema exists.

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 with no filler, and the destructive warning is front-loaded right after the core purpose. Efficient, though the brevity borders on under-specification rather than tight 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 covers return values, but with zero annotations and 0% parameter coverage, the description is too thin for a read/write tool that alters approval state. It omits the parameter trigger, permission expectations, and any sibling routing.

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

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

Schema coverage is 0%, so the two parameters (content, feature_name) are wholly undocumented. The description hints at content's read/write role through 'lê ou salva' but never names content or feature_name or explains the null/default convention, leaving the semantics largely to inference.

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 pair (reads or saves) and a specific resource (requirements.md), which is enough to identify the operation. It does not differentiate itself from siblings like spec-init, spec-design, or spec-approve, but the resource target 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?

The dual read/write behavior is implied but the trigger condition is never stated - an agent must infer that passing content means save and omitting it means read. No mention of when to prefer this tool over spec-init or spec-design, and no 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 implies a reporting read ('Mostra'), but never confirms it is non-mutating, requires no elevated permissions, or has any side effects, and gives no hint about pagination or freshness of the data.

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 short sentence that front-loads the verb and resource with no filler. It is efficient, though its brevity is more under-specification than disciplined concision.

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

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

An output schema exists, so return values need not be explained. However, with no annotations, no parameter documentation, and no usage context, the definition is only minimally sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0% and the single parameter feature_name is undocumented. The description does not clarify whether feature_name is an identifier, slug, or display name, nor whether it must match an existing spec created by spec-init.

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: shows approvals and task progress for a feature. That is clear enough to separate it from validate_spec or spec-approve, but it never explicitly names a sibling or states its scope relative to the other spec-* tools.

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 indication of when to call this versus spec-approve, spec-tasks, or validate_spec. The agent must infer that this is a read-only progress report rather than a state-changing action, which is a real risk given the sibling names.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints at a mutation path ("salva") but never states whether an existing tasks.md is overwritten, whether the operation requires prior approval state, or what permissions are needed — significant gaps for a tool that can write.

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

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

A single short sentence with the resource and the precondition front-loaded, and no filler. It is efficient, though its brevity is partly a symptom of under-specification rather than tight editing.

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, but for a two-parameter, no-annotation tool with 0% schema coverage the definition leaves the read-vs-write trigger, parameter meaning, and mutation side effects unexplained. Not enough for an agent to invoke it correctly without guessing.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate and does not. It implies content maps to tasks.md, but never explains content versus feature_name, nor how feature_name scopes the file path, nor the null default that switches between read and write.

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 resource (tasks.md) with clear verbs (reads or saves) and a timing condition (after design approval), which orients it against stage-based siblings like spec-design and spec-impl. However, the dual read/write mode is not disambiguated, and no sibling is named as the counterpart to this step.

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?

"Depois da aprovação do design" gives an implicit workflow stage, suggesting it follows spec-approve/spec-design. But there is no explicit when-to-use vs alternative, no statement of when to pass content (save) versus omit it (read), and no mention of the adjacent spec-impl step.

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 burden, and it does disclose the target file path and that the tool may write to it. However, it omits whether initialization overwrites existing content, permission requirements, or error behavior on a missing file.

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

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

A single front-loaded sentence with no filler. It is efficient, though arguably too terse given the undocumented parameters.

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 no annotations need covering. But with 0% schema coverage and two undescribed parameters driving a read/write duality, the description leaves the agent without enough to invoke the tool confidently.

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 neither parameter is named in the description. The 'read or initialize' phrasing only vaguely gestures at the action parameter and says nothing about content, leaving both undocumented.

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 pair (reads or initializes) and a precise resource (the constitution at .kiro/steering/constitution.md). It is distinguishable from the spec/skill siblings, though it never explains what a 'constitution' is in this system.

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

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

The description implies two modes (read vs. initialize) but gives no guidance on when to pick each, no prerequisites, and no reference to any sibling tool. An agent must infer that supplying content triggers initialization.

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 full behavioral burden and does not meet it. It never states whether the operation is read-only, whether it mutates or persists anything, what happens on failure, or what constitutes a passing vs. failing validation.

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

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

A single short sentence with no filler; appropriately sized for a simple tool. It is front-loaded with the verb, though it says too little rather than too much.

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, but for a validator the description should still convey what 'required sections' means and the expected input. Given the presence of several near-identical validate_* siblings, this description leaves key context missing.

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

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

Schema description coverage is 0% for the single required parameter 'feature_name', and the description does not mention it at all. It is unclear whether it expects a feature identifier, a path, or a spec slug — the description fails to compensate for the coverage 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?

The description names a specific verb and resource ('Valida as seções necessárias do design técnico'), so the purpose is discernible. However, it gives no differentiation from siblings like validate_spec, validate-gap, or spec-design, leaving the agent unsure which validator applies to a given artifact.

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 at all on when to use this tool versus validate_spec/validate-gap, nor any stated prerequisite (e.g. that a technical design must already exist). The agent must infer everything from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does not state whether this is a read-only comparison, what a detected gap means, or what action follows. It only restates that a comparison happens, adding no traits beyond the name.

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 definition is a single sentence with zero padding, which is structurally front-loaded. But its brevity stems from under-specification rather than economy, so it is adequate at best.

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 presence of an output schema removes the need to explain return values, but with no annotations and 0% parameter coverage the description should do more. It never clarifies the gap-analysis semantics or workflow position, leaving an agent unable to invoke it confidently against its siblings.

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 description only loosely hints at implementation_summary via "resumo fornecido da implementação". The required feature_name is never explained, nor is the expected format or relationship between the two inputs, so the description does not compensate for the coverage 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?

The description names a verb ("Compara") and the resources being compared (approvals, tasks, an implementation summary), so the general purpose is discernible. However, it never explains what a "gap" is or how this differs from siblings like validate-spec or validate-design, leaving the specific intent vague.

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, when not to, or which sibling to prefer. The agent must infer its place in the spec workflow entirely, despite a crowded set of near-named validation siblings.

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, yet it omits whether validation is read-only, whether it mutates or repairs the spec, what permissions are needed, and what a failed validation means. Only the vague term 'legacy spec' hints at scope, with no elaboration.

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

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

A single short sentence with no filler, front-loading the verb. It is efficient, though so terse that brevity shades into under-specification rather than concision.

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

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

An output schema exists, so return values need not be described. Still, for a validation tool sitting among many similar validators, the description lacks the scope and routing detail an agent needs to select it confidently.

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

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

Schema description coverage is 0% for the single spec_id parameter, so the description should compensate but does not: it never explains what a spec_id is, what format it takes, or where it comes from. The one sentence adds no parameter meaning.

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?

Names a specific verb (validate) and resource (required sections of a legacy spec), so the action is clear. However, it offers no differentiation from sibling validators such as validate-design and validate-gap, leaving the agent to guess which validator applies to its case.

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 indication of when this tool should be used, what qualifies as a 'legacy spec', or how it relates to the other validate-* siblings. The agent must infer the triggering condition entirely.

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