5 exercises — choosing precisely the right evaluative word in PR reviews, architecture discussions, and incident postmortems. Covers the full spectrum from elegant to brittle with real workplace scenarios.
Evaluative word spectrum in tech
Word
Tone
Means in tech context
elegant
very positive
Simple, clean, and clever — solves the problem beautifully
robust
very positive
Handles failures, edge cases, and load reliably
idiomatic
positive
Uses the natural patterns and conventions of the language/framework
pragmatic
positive
Practical; solves the real problem without over-abstracting
viable
neutral
Works and is feasible — but not necessarily the best option
appropriate
neutral
Fits the context and standards; suitable
opinionated
neutral
Enforces a specific approach (frameworks/tools); not a personal insult
suboptimal
negative
Works but is worse than the best available option
over-engineered
negative
More complex than the problem requires
brittle
negative
Fragile; breaks easily when conditions or dependencies change
0 / 5 completed
1 / 5
In a PR review, a senior engineer comments on a function that manually re-implements Array.prototype.reduce: "This implementation is correct but feels somewhat ___. The built-in reduce is more idiomatic and will be immediately recognisable to other contributors." Which evaluative word fits best?
Over-engineered means a solution is more complex than the problem requires — it does more work than necessary, often at the cost of readability or maintainability. Re-implementing a standard library function manually is a textbook example. Breakdown of each option: (A) brittle — a correct value but wrong meaning here; brittle code breaks easily when inputs or conditions change (e.g., hardcoded assumptions, no error handling); (B) ✅ over-engineered — unnecessary complexity where a simpler solution exists; (C) pragmatic — positive; means practical and focused on what works rather than theory — the opposite of what the reviewer wants to say; (D) opinionated — neutral to positive in tech; describes software or approaches that enforce a particular way of doing things (e.g., "Rails is an opinionated framework"). Use it carefully — it is not inherently negative. In code reviews, the spectrum from praise to critique: elegant → idiomatic → appropriate → workable → suboptimal → over-engineered → brittle.
2 / 5
In an architecture RFC, a reviewer writes about a proposed caching solution: "The proposed approach is technically ___, but I'd question whether the added complexity is justified given the current traffic volumes." Which word signals technically acceptable but questionable?
Viable means something is capable of working — it is feasible, possible, and not technically broken — but it does not imply it is the best or most efficient option. This makes it perfect for the "technically works, but…" construction in RFC reviews. Breakdown: (A) robust — strongly positive; means the system handles failures, edge cases, and load gracefully; using "but I'd question…" after "robust" creates an odd contrast; (B) elegant — highly positive; implies simplicity, beauty, and clarity of design — again, the "but" contrast would be jarring; (C) ✅ viable — neutral/cautiously positive; it works, but viability alone is not sufficient reason to adopt it; (D) suboptimal — negative; means it is worse than the best solution; you would not follow this with "but I'd question" — you would just say it is suboptimal. RFC vocabulary tip: viable and appropriate are your neutral "yes-but" words; robust and elegant are endorsements; suboptimal and brittle are rejections.
3 / 5
A senior engineer leaves this PR comment on a 400-line function handling 12 different concerns: "This function works, but it's doing too much — parsing, validation, DB writes, and notification dispatch all in one place. The design is ___." Which evaluative term best describes this anti-pattern?
Brittle describes code or architecture that is fragile — it breaks easily when any one of its many dependencies, assumptions, or interleaved concerns changes. A monolithic function handling 12 concerns is brittle because changing the validation logic might accidentally break the notification dispatch. The reviewer is pointing to fragility, not just complexity. Breakdown: (A) pragmatic — positive; practical and effective, not overly theoretical; this is a compliment in tech; (B) idiomatic — positive; means the code follows the natural conventions and style of the language or framework — a compliment; (C) ✅ brittle — the 400-line god function is the classic brittle design; (D) appropriate — positive/neutral; suitable for the context. A common PR comment structure: name the problem (too many concerns) → label it evaluatively (brittle) → suggest the fix (split into smaller functions, apply SRP). Tip: in code reviews, brittle focuses on fragility/risk; over-engineered focuses on unnecessary complexity. These are different problems.
4 / 5
An architect comments on a microservice that bypasses the team's shared authentication library and re-implements JWT verification from scratch: "Re-implementing JWT verification here is ___. We have a shared auth library precisely to avoid divergence — please use @company/auth-sdk instead." Choose the most precise evaluative word.
Inappropriate means the approach does not fit the context, standards, or norms of the situation — not that it is technically wrong, but that it violates an established team contract or convention. The reviewer is not saying the implementation is bad on its own — they are saying it is the wrong approach for this context (there is an agreed shared library). Breakdown: (A) suboptimal — means worse than best, but implies a performance or efficiency judgement rather than a standards violation; (B) inelegant — focuses on aesthetic or style issues (clunky, verbose, not clean); (C) ✅ inappropriate — violates team norms; the strongest choice when an action contradicts an established convention or policy; (D) opinionated — describes a tool or framework that enforces a specific approach; cannot be used to describe a piece of code negatively this way. Evaluative words by register: inelegant is gentle; suboptimal is technical; inappropriate is firm; unacceptable is the strongest — escalate carefully.
5 / 5
In a postmortem, a team writes about their incident response: "Our on-call runbook proved ___ during the incident — the steps were clear, the rollback procedure worked on the first attempt, and the team resolved the outage in under 20 minutes." Which evaluative word fits the positive outcome?
Robust is the highest-level positive evaluative word for systems, processes, and infrastructure in tech. It means something performed reliably under real conditions — it handled failure gracefully, worked as designed under pressure, and held up. A runbook that enabled a 20-minute resolution with working rollback steps is the definition of robust. Breakdown: (A) viable — neutral; just means it could work. You would not use "viable" as a compliment in a postmortem; (B) appropriate — mild positive; suitable and fitting, but underwhelming for describing a runbook that saved the day; (C) ✅ robust — strong endorsement; it performed under real pressure; (D) pragmatic — positive but focuses on the practical mindset of the people who wrote it, not on its actual performance under load. Evaluative word strength in tech (positive scale): workable < viable < appropriate < pragmatic < robust < elegant. Use "robust" for systems, runbooks, and architectures that proved themselves under real conditions.