Skip to main content
Glama
marvkr

Better Design

Get Team Rules

get-team-rules
Read-onlyIdempotent

Retrieve your team's build and review rules before starting a task so every agent follows the same guidelines. Pass a project ID, screen, and parts to get only the rules that apply.

Instructions

Read the rules this account's team wrote for how agents should build and review their product. Call it at the start of a task, then follow the rules in everything you build. get-review-rules and check-comprehension already check work against them.

For a client project, pass projectId, the screen you are building and the parts you will use. The answer adds only what that screen needs: the project's guidelines, the use, never and pairing rules for those parts, the brand-wide bans and the specs saved on the screen. It also adds Better Design's own rules for each part that has them, such as when a dialog is the wrong choice; the project's rules win over them.

Returns the team's own Markdown document. When the team has none yet, it returns the steps and the outline to draft them with the person.

Input Schema

NameRequiredDescriptionDefault
partsNoThe parts and values you will build with, such as ["Button", "--primary"]. Only their rules come back, with the parts the screen's specs name. Needs projectId.
screenNoThe screen you are building, such as "sign-up". Adds the specs saved on it. Needs projectId.
contextNoOptional. One sentence on WHY you are calling this and what the user asked for (e.g. 'adding nav icons for the fintech dashboard'). Used only for usage analytics; does not change the result.
projectIdNoA Better Design project id, as create-design-system returns it. The project must belong to this account.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.6/5.0
Behavior5/5

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

Annotations already certify a safe, idempotent read; the description goes well beyond them by describing the return artifact (the team's Markdown document), the scoped-answer behavior when projectId/screen/parts are passed, the precedence rule that project rules beat Better Design's own rules, and the fallback that returns drafting steps and an outline when no team rules exist yet. That fallback and precedence behavior are things no annotation or schema could convey.

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

Conciseness4/5

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

Four short paragraphs, front-loaded with the core action and the call-at-task-start directive. It is dense with useful information rather than padded, though "Returns the team's own Markdown document" mildly echoes the opening sentence rather than adding new detail.

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

Completeness5/5

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

With no output schema and an all-optional four-parameter schema, the description carries the burden well: it covers what is returned, how results vary with projectId/screen/parts, rule precedence, and the no-rules-yet fallback. Nothing an agent needs to call this correctly is missing.

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

Parameters4/5

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 real semantic value: it explains that passing projectId plus screen and parts narrows the answer to only what that screen needs — guidelines, use/never/pairing rules, brand bans, saved specs. That tells the agent what each parameter changes in the output, not just its format.

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

Purpose5/5

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

States a specific verb and resource — read the team-authored rules for how agents build and review the product — and immediately separates itself from get-review-rules and check-comprehension, which check work against those rules rather than supply them. An agent can pick this tool over its many siblings without opening a schema.

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

Usage Guidelines4/5

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

"Call it at the start of a task, then follow the rules in everything you build" gives explicit timing and follow-through, and the sibling sentence clarifies how get-review-rules/check-comprehension relate. It stops short of stating when not to use it (e.g., when rules were already fetched this session), but the positive guidance is clear.

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