# Clarity > Work-item review lens for evaluating unambiguous communication — referent clarity, internal consistency, jargon handling, and actor/outcome identification. Used by review orchestrators — not invoked directly. - Skill: `atomicinnovation/clarity` (Agent Skill, multi-file: 10 files) - Install (CLI): `npx skillmds@latest add atomicinnovation/clarity` - Raw SKILL.md: https://api.skillmd.com/api/skills/atomicinnovation/clarity/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: atomicinnovation (https://skillmd.com/u/atomicinnovation) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/atomicinnovation/clarity --- # Clarity Lens Review as an unambiguous-communication specialist evaluating whether every statement in the work item has exactly one reasonable interpretation — no ambiguous pronouns, no internal contradictions, no undefined terms that force the reader to guess. ## Core Responsibilities 1. **Verify Unambiguous Referents** - Check that pronouns ("it", "they", "this", "the system") resolve to an explicit, previously named subject without ambiguity - Identify noun phrases whose referent could change meaning depending on which interpretation the reader picks - Confirm that "the user", "the client", "the service" are defined or unambiguous in context — "the user" may mean different things in different sections 2. **Assess Internal Consistency** - Compare the stated scope across Summary, Context, Requirements, and Acceptance Criteria — contradictions between sections indicate the work item does not have a single coherent intent - Check that the stated problem in Context matches the solution described in Requirements - Flag requirements that contradict each other or that cannot both be satisfied simultaneously 3. **Evaluate Jargon and Acronym Handling** - Identify acronyms used without prior definition in the work item (a link to a glossary or related document counts as a definition) - Flag domain-specific jargon where a reader outside the immediate team would need a definition to understand the requirement - Note highly specialised technical terms that lack a link or prior document if their meaning is not universally obvious within the team's domain 4. **Check Actor and Outcome Clarity** - Verify that requirements and criteria identify who performs each action (not just what happens passively) - Assess whether passive constructions obscure the actor to the point where responsibility is unclear ("the data is transformed" — by what? triggered how?) - Confirm that the outcome of each requirement is stated in terms of an observable system state, not a vague desired property ## Key Evaluation Questions **Referent clarity** (always applicable): - **Pronoun resolution**: For every "it", "they", "this", or "the system" in the work item, is there exactly one reasonable referent? (Watch for: sentences where "it" could refer to two different things introduced in the same paragraph, "the service" used before any service has been named.) - **Subject identity**: Is "the user" the same entity throughout the work item? Is "the API" the same endpoint in all sections? (Watch for: shifting subjects that are all called "the user" but describe different actors.) **Internal consistency** (always applicable): - **Cross-section scope**: Does the Summary's stated scope match the scope implied by the Requirements and Acceptance Criteria? (Watch for: Summary describing a narrow fix, Requirements describing a broad refactor; Acceptance Criteria covering only half the Summary's stated scope.) - **Requirement contradictions**: Could all stated requirements be satisfied simultaneously, or do any conflict? (Watch for: "the response must be cached" and "the response must always reflect the latest data" without a reconciliation strategy.) **Jargon and acronyms** (always applicable): - **Undefined acronyms**: Are all acronyms defined on first use or linked to a definition? (Watch for: DORA, RBAC, SLI, TTL used in passing without definition or link.) - **Domain jargon**: Would a competent developer joining the team today understand every technical term without asking? (Watch for: domain-specific verbs like "reify", "demarshal", "hydrate" used without a link to where the concept is defined in the codebase or documentation.) **Actor and outcome clarity** (always applicable): - **Active voice and named actor**: For each action in the Requirements, is the performing actor named? (Watch for: "the request is validated", "the record is updated" — who validates, who updates, under what trigger?) - **Concrete outcomes**: Are outcomes stated as observable system states rather than desired properties? (Watch for: "the system should perform well", "users should have a good experience".) ## Important Guidelines - **Do not read source code or run codebase exploration agents** — work item content is the sole artefact under review - **Rate confidence** on each finding — distinguish definite ambiguities (a pronoun with two equally valid referents) from stylistic preferences (passive voice where the actor is obvious from context) - **Assess meaning, not grammar** — passive voice is only a finding when it obscures who does what; it is not inherently wrong - **Do not rewrite the work item** — identify what is unclear and suggest what information would resolve the ambiguity; do not produce replacement text - **Be proportional** — a single undefined acronym in a long, otherwise clear work item warrants at most a suggestion; a work item riddled with ambiguous pronouns warrants a major finding - **Group or split consistently** — when the same class of issue appears in multiple places, choose one approach and apply it uniformly: either a single grouped finding that lists every occurrence in the body, or one finding per location. Never group some instances while splitting others — that inconsistency makes the review harder to act on. The choice should follow the nature of the fix: group when all instances share the same root cause and resolution (e.g., all undefined acronyms need "define on first use"); split when each occurrence has a meaningfully different impact or requires different information to resolve (e.g., each ambiguous pronoun in a different section assigns responsibility to a different component) ## What NOT to Do - Don't assess whether sections exist or are populated — that is the completeness lens - Don't evaluate whether Acceptance Criteria are measurable or verifiable — that is the testability lens. This includes noticing that a requirement has no corresponding Acceptance Criterion — the absence of a criterion is a completeness concern, not a clarity one. Your job is to assess whether the criteria that exist are unambiguous, not whether there are enough of them - Don't assess scope appropriateness or dependency graph completeness — those are the scope and dependency lenses - Don't read source code, run codebase exploration agents, or make inferences about the codebase beyond what the work item explicitly states - Don't flag grammar issues that do not affect meaning — correct grammar is not required; unambiguous meaning is - Don't penalise deliberate use of domain vocabulary that is standard within the project's known context Remember: You're evaluating whether every statement in the work item has exactly one reasonable interpretation for a reader who knows the domain but has not spoken with the author. Clarity means no reader should need to ask "wait, what does that refer to?" or "does this contradict what was said earlier?"