recipebooq

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

The description says the tool 'Adds one screen designed in the App Builder to a project' and 'never rewrites existing files,' which implies a write operation creating or modifying files. This contradicts the readOnlyHint=true annotation, which declares the tool does not modify its environment. Even though it later says it 'returns the screen file,' the initial framing is inconsistent with the annotation.

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 reasonably concise and front-loads the subscription requirement and core action. It could be structured more clearly (e.g., separating prerequisites from behavior), but it avoids waste.

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

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

Given the tool's complexity (5 parameters, nested object, no output schema) and the rich annotations, the description covers the subscription requirement, return values, two operational modes, and file-safety behavior. It is nearly complete, though it fails to resolve the read-only tension cleanly.

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 adds meaning beyond the schema by explaining the effect of the manifest parameter: with it, the tool returns the screen file, route, and registration line; without it, a self-contained screen file. This clarifies the two invocation modes.

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: 'Adds one screen designed in the App Builder to a project.' It does not differentiate from sibling tools like propose_screen or emit_app, and the verb 'Adds' creates some ambiguity, but the core purpose is 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?

Implies usage via the subscription prerequisite and the two modes based on whether .opointo/files.json is supplied, but it does not name alternatives (e.g., propose_screen) or explicitly say when not to use this tool. Guidance is present but incomplete.

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 readOnly, idempotent, non-destructive, and closed-world. The description adds genuine value beyond them by clarifying it is a 'read-only text scan, not a guarantee' and therefore best-effort rather than exhaustive — a limitation an agent would otherwise not know.

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, front-loaded with the bug classes and closed with the scope caveat and sibling routing. No sentence is 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?

With no output schema, the description correctly conveys expected findings (blank renders with no error) and sets expectations that results are heuristic, not guaranteed. Nothing needed to invoke it correctly is 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 coverage is 100% and there is only one parameter ('code', 'the TSX to check'), so the schema already carries the semantics. The description adds nothing about the input format or size limits, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Scans') and resource ('TSX that uses these components') and enumerates the exact bug classes it detects. It is clearly distinguishable from verify_app, which it explicitly names as the project-wide alternative.

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

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

Explicitly frames this as a narrow per-snippet check and routes whole-project validation to verify_app. It stops short of stating explicit exclusions or prerequisites (e.g. what happens if the snippet lacks these components), so it is strong 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?

Annotations already declare readOnly, idempotent and non-destructive, so safety is covered; the description adds real value beyond them by disclosing the subscription requirement, the daily allowance and the fact that per-step calls are exempt. It does not describe write behavior or error conditions, keeping it from a 5.

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

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

Three sentences, front-loaded with the gating prerequisite and then the operation and return contract. Every sentence carries weight; only minor compression is possible.

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, the description correctly summarizes the return shape (files with target paths, an install line, ordered steps with checks). Combined with the subscription and quota notes, an agent has enough to call it correctly, though error/edge behavior for invalid appId is unaddressed.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds semantics the schema lacks: `step` yields one step in full and is exempt from the daily allowance, and it cross-references the recipe as the source of valid step ids. That is genuine meaning beyond the schema text.

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 relationship: it transforms an App Builder design into a working Expo app, then enumerates the concrete artifacts (navigation, providers, tab bar, screens, components). The return contract ('a recipe: every file with its target path, one install line and ordered steps') further distinguishes it from siblings like propose_app and verify_app.

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 a clear prerequisite ('Needs a subscription') and instructs the agent on the `step` mode including its quota behavior ('does not count against the daily allowance'). It does not explicitly route between alternatives such as propose_app or verify_app, so it falls 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.

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds real behavioral value the annotations cannot: results are ranked, and the catalog may intentionally return nothing when the platform's native control is preferable — a non-obvious negative-result contract.

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 front-loaded sentences with no filler, leading with what the tool does and the ranking behavior before the omit-need shortcut. Slightly dense phrasing ('ships nothing on purpose') 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?

With no output schema, the description usefully sketches what comes back (ranked components, purpose text, whether a real system control renders). The only notable gap is the unexplained `category` enum, which the schema also fails to document.

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 50%, and the description only compensates for `need` (omit it to list all). The `category` enum (controls/chrome/surfaces) is left entirely undefined in both schema and description, so the agent must guess what those buckets mean.

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 ('Finds the component') scoped to a plain-language UI need, and adds the distinctive behavior of ranked results plus deliberate-absence signaling. It implicitly separates itself from the id-lookup sibling (get_component) but never names it, so differentiation is inferential rather than explicit.

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

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

The description gives one concrete usage rule: omitting `need` lists every component with purpose and system-control status. Beyond that it offers no when-to-use versus alternatives guidance or prerequisites for the ranked search path.

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, idempotentHint, destructiveHint=false and closed-world, so the safety profile is fully covered and the description need not repeat it. It adds only that results are scoped per topic and are conceptual guidance rather than live state. No error, pagination, or freshness behavior is disclosed.

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

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

The single sentence opens with the fragment 'How an app is set up so these components work and follow its theme, one topic at a time:', which is not a clause and delays the actionable content. The enumerated topics arrive only after a heavy preamble, so the definition is not front-loaded and reads awkwardly.

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, the description carries the burden of describing return content, and it does so for all three topics. The emit_app note gives useful context about when the setup is already wired. Only the platform-scoping behavior for 'rules' is undocumented.

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 only 50%, so the description must compensate — and it does for the required 'topic' parameter by explaining what each of the three enum values yields (providers/theme/rules). The optional 'platform' parameter's 'rules only' constraint is left entirely to the schema, which is the remaining 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 the resource (app setup guidance) and enumerates the three concrete outputs — app-root providers in working order, theme hooks and token scales, or catalog-wide rules — so an agent knows what each topic returns. The verb is buried ('How an app is set up...'), but the content is specific enough to separate it from siblings like get_component or find_component. It stops short of explicitly contrasting with those siblings.

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

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

Usage is implied rather than stated: 'one topic at a time' and the enum values tell the agent how to call it, and 'An app built by emit_app already has all three wired' hints that the tool may be redundant after emit_app. There is no explicit when-to-use/when-not rule or named alternative for looking up component details, so guidance stays inferential.

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, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: it discloses the shape of the response, per-platform rendering differences, required root providers, and 'runtime rules that stop it rendering blank' — useful for an agent deciding whether the call is sufficient.

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 dense, front-loaded sentence that lists exactly what comes back with no filler. Slightly list-like and could be scannable as bullets, 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?

With no output schema, the description carries the full burden of describing the return payload and does so thoroughly — props, defaults, allowed values, platform rendering, providers, dependencies and runtime rules. Nothing an agent needs to call it correctly is 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 100%, and the description adds no information about slug or platform beyond the schema (the enum and 'only the rules that hold there' note live in the schema itself). Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a clear resource and scope: it returns everything needed to write a call site for one component, enumerating props/types/defaults, platform rendering, providers, dependencies and runtime rules. An agent can distinguish it from find_component (discovery) and install_component (mutation/installation), though no sibling is named 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?

The framing 'everything needed to write a correct call site' implies pre-use before installing or emitting a component, but there is no explicit when-to-use, when-not-to-use, or named alternative such as find_component. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds the subscription gate and spells out the returned payload (install order, exact target paths, expo install line, provider/runtime requirements), going meaningfully beyond the annotations.

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

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

Two sentences, with the eligibility condition front-loaded before the functional description, and no filler. The second sentence is a dense run-on list, but every item earns its place by telling the agent what the call returns.

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, the description carries the burden of explaining the return value, and it does so concretely (file list with target paths, install line, providers, runtime rules). Combined with the subscription caveat, an agent has what it needs to call and interpret 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 100% and the single slug parameter is already documented with examples ("button", "bottom-sheet"). The description adds no additional slug semantics such as valid identifier forms or lookup behavior, 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 ("Adds one component to an existing project") and then enumerates exactly what the call yields (files in install order with target paths, the expo install line, providers, runtime rules), which separates it from siblings like get_component or find_component. It is clear but does not name an alternative to disambiguate from add_screen/update_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?

The opening clause gives a real precondition ("Needs a subscription, except for the free foundation components"), which is useful gating context. However, there is no explicit when-to-use vs. when-not guidance and no reference to sibling tools such as find_component for discovery or update_components for edits, leaving routing 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?

Annotations mark it non-read-only, non-destructive and non-idempotent, and the description usefully adds that the result is an unsaved design (no persistence), that validation errors come back with a path and a fix, and that dryRun/format flags alter behavior. This is genuine behavioral context beyond the annotation flags.

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

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

Front-loaded with the core action and the link result, then the dryRun/format caveats. The narrative middle ('The person sees every screen ... hands it back') is somewhat verbose but conveys the intended human-in-the-loop workflow, so it earns most of its space.

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 complex nested-schema tool with no output schema, the description adequately explains what comes back (a link, or per-problem paths and fixes) and the flag-driven modes. A mention of the missing output shape or error/return specifics for the success path would round it out.

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 'format' parameter has no schema description, yet the description documents it ('returns the format and every block'), and dryRun is clarified as 'check ... without making a link'. The bulky app schema is mostly self-documenting, so description adds value where the schema is silent.

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 ('design an app', 'send an app ... get back a link') and names the counterpart tool emit_app, so an agent can tell it apart from the emit path. It does not differentiate from the sibling propose_screen, which shares the 'propose' naming, leaving some ambiguity between the app-level and screen-level variants.

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 context is clear: send a design to preview it as an unsaved App Builder link, then hand it back to emit_app. It also explains the dryRun branch ('checks without making a link'). No explicit when-not-to-use or alternatives beyond emit_app are stated.

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

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

Goes beyond the annotations by disclosing that the result is a new, unsaved design the person can edit, that validation problems come back with path and fix, and that dryRun reports without creating a link. Annotations only carry the generic non-destructive/not-idempotent profile, so this adds real behavioral value.

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 the core action and return value, then sibling routing. Slightly dense with parentheticals but every sentence carries information an agent needs.

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 the return (an App Builder link) and error shape, plus both boolean flags and the composition source. The only thin spot is what the format mode actually emits, a minor gap for a 3-param 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?

Adds meaning beyond the 67%-covered schema: it explains dryRun ('checks without making a link') and format ('format: true returns the format'), while composition's structure is documented in the schema itself. It stops short of fully defining the format-mode output, but the two behavioral flags are well clarified.

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 ('design a single screen', 'send one screen ... get back a link') and explicitly contrasts itself with the sibling propose_app ('For a whole app with navigation, propose_app is the matching tool'), so an agent can separate them without opening schemas.

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 clear context for when to reach for this tool (single screen in the Composition format that add_screen builds from) and names the alternative for the whole-app case. It lacks explicit when-not-to-use conditions beyond that sibling pointer, but the routing guidance is solid.

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 readOnly, idempotent, and non-destructive, and the description resolves the tension with the 'update' name by clarifying it only reads and returns changed files. It adds useful context beyond annotations: subscription requirement and the guarantee that it 'never touches the customer's own screens.'

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 dense sentences with essentially no filler, though the leading 'Needs a subscription' puts a precondition ahead of the primary purpose rather than front-loading what the tool does.

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 tool with full schema coverage and clear annotations, the description covers the key behavior including what it returns and what it avoids touching. Return-format detail is light, but annotations and schema carry the rest.

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 manifest, current, and acceptSplit in detail. The description adds only an oblique reference to changes needing a code edit and does not expand on any 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?

The description gives a specific action set — reads the project's .opointo/files.json and returns only opointo-supplied files that changed since export — which is far more concrete than the ambiguous name 'update_components'. However, it does not explicitly distinguish itself from siblings such as install_component or get_component, 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?

A precondition is stated ('Needs a subscription') and the description implies the re-export/months-later scenario, but it never says when to choose this over install_component, get_component, or check_snippet. Usage is implied rather than contrasted with alternatives.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds value beyond them by disclosing the subscription requirement and the pre-build validation role, but says nothing about how findings are reported or whether it fails fast vs. collecting all issues.

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 dense sentences with no filler; the subscription prerequisite and pre-build framing are front-loaded. The long comma-separated checklist is information-rich but slightly compressed, which is acceptable for the amount it conveys.

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 5-parameter tool with nested objects and no output schema, the description covers inputs, precondition, and the nature of the checks performed, which implicitly describes what the caller learns back. It stops short of describing result shape or error behavior, a minor gap given no output schema exists.

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 60% and the description only restates the input families (files with byte sizes, package.json dependencies, project config, toolchain versions) without adding format or semantic detail beyond what the schema documents. Under the high-coverage baseline rule this is a straight 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a precise verb and resource ('Checks an emitted app before it is built') and enumerates the concrete failure classes it detects (missing files, altered copy-verbatim files, absent packages, expo-router config merge, Xcode buildability). This clearly separates it from siblings like emit_app, check_snippet and propose_app.

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 the operative timing context — run before the app is built — and the gating prerequisite ('Needs a subscription'), which is exactly the kind of usage guidance an agent needs. It does not name alternatives or state when not to use it, 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.