Developer Productivity
You can't unit test for taste: why the phrase matters
You can't unit test for taste The phrase "You can't unit test for taste" is a useful reminder that not every quality decision fits neatly into a unit test. Some parts of software a
You can't unit test for taste
The phrase "You can't unit test for taste" is a useful reminder that not every quality decision fits neatly into a unit test. Some parts of software are easier to check with repeatable tests, while other parts depend on judgment, context, and human preference.
That distinction matters in engineering teams, including AI offices like Nonilion, where human + AI collaboration can help with repeatable work without turning every quality decision into a test.
01What unit tests are good at: checking repeatable behavior
Want your team to run this workflow with AI-native execution?
Unit tests are most useful when they verify code in isolation and the expected result is clear. They help teams check that a piece of code behaves the same way under the same conditions.
That is why people often ask, "Why should unit tests test only one thing?" The benefit is clarity. A smaller test is easier to understand, easier to maintain, and easier to debug when it fails. If a test covers too many behaviors at once, it becomes harder to tell what broke.
In practical terms, unit tests are good for:
- deterministic outputs
- isolated logic
- repeatable behavior
- code paths with clear expectations
- checking one behavior at a time
02Why taste is different: subjective judgment, context, and human preference
Taste is not the same as correctness. A function can return the right value and still produce a poor user experience. A name can be technically valid and still feel awkward. A workflow can be logically correct and still not fit how people actually work.
That is why people say you can't unit test for taste. Taste depends on context, audience, and preference, so it is not always a single measurable answer.
The difference shows up when code is technically sound but the result still needs review. In those cases, the logic may be correct, but the judgment call is still open.
03Where unit tests break down: false confidence, over-mocking, and brittle assertions
When teams try to force taste into unit tests, they can get false confidence. The test suite may pass while the product still feels wrong.
One of the recurring concerns in the source data is mocking. The question "Would you say that mocking is a 'test smell' and makes unit ..." reflects a common worry: if a test depends too heavily on mocked behavior, it may become brittle and fragile. That can make tests pass for the wrong reasons or fail when implementation details change, even if the user-facing behavior is still fine.
This is where brittle assertions become a problem. If a test checks too many internal details, it may protect the structure of the code more than the actual value of the feature. That can create a system that is easy to test but hard to evolve.
So while unit tests are useful, they are not a substitute for judgment. They should verify the machine, not pretend to judge taste.
04What to test instead: logic, contracts, edge cases, and deterministic outputs
If taste is not unit-testable, what should teams test?
The answer is the repeatable part of the system:
- core logic
- contracts between components
- edge cases
- deterministic outputs
- isolated behavior without dependencies
This is where unit tests are strongest. They can confirm that a function behaves consistently, that a rule is applied correctly, or that a boundary case does not break the system.
For code with difficult to predict results, the goal is not to force a subjective judgment into a unit test. Instead, teams can test the parts that are still measurable: the rules, the inputs, and the expected behavior under known conditions.
05How teams should handle taste decisions: review rituals, async feedback, and acceptance criteria
If unit tests are not the right tool for taste, teams need another workflow.
A practical approach is to use review rituals and acceptance criteria for subjective decisions. Human reviewers can evaluate whether a product choice feels coherent, whether the copy sounds right, or whether the workflow matches the intended experience. Async feedback also helps, because it gives people time to respond thoughtfully instead of treating taste as a binary pass/fail check.
This is where AI-assisted collaboration can help without taking over the decision. In a workspace like Nonilion, AI agents can draft options, organize feedback, and surface the repeatable checks while humans review the parts that depend on product sense and context. That makes the workflow faster without confusing automation with judgment.
00What this means for AI offices like Nonilion
In AI offices, the boundary between testing and taste becomes even more important.
AI agents are useful for drafting, simulating, and checking the repeatable parts of work. They can help with structured tasks, compare outputs against known rules, and support async execution when a team needs to move quickly. But they do not replace the human role in deciding whether something is elegant, clear, or aligned with the product.
That is why Nonilion fits this conversation as an example of human + AI collaboration in a shared workspace. The point is not to automate judgment away. The point is to let agents handle the measurable pieces so people can focus on the subjective ones.
07A practical decision boundary: unit tests vs integration tests vs human critique
A useful way to think about the boundary is this:
- Unit tests: check isolated, repeatable behavior
- Integration tests: check how parts work together
- Human critique: judge taste, fit, and coherence
This division helps teams avoid using the wrong tool for the wrong job. If the question is "Does this function return the right result?" a unit test is appropriate. If the question is "Do these parts work together as expected?" integration testing may be better. If the question is "Does this feel right to the user?" the answer belongs to people.
That is the practical lesson behind the phrase You can't unit test for taste.
08When to automate and when to pause: a checklist for engineering and product teams
Here is a simple decision checklist:
Automate when:
- the output is deterministic
- the behavior is repeatable
- the rule is clear
- the failure mode is specific
- the goal is to protect known logic
Pause and use human judgment when:
- the decision is subjective
- the result depends on context
- the issue is naming, copy, or UX polish
- the workflow may be technically correct but still feel off
- the team is debating taste rather than correctness
This kind of boundary is especially useful in AI-assisted teams, where agents can accelerate the mechanical side of work but should not be treated as the final authority on quality.
09How this platform supports human + AI collaboration on subjective work
For this platform, the practical opportunity is not to unit test taste, but to build a workflow where AI agents handle the repeatable checks and humans handle the final critique.
That means:
- agents can draft and organize options
- teams can review asynchronously
- repeatable behavior can be checked automatically
- humans can decide on UX, naming, copy, workflow fit, and product coherence
This is a strong model for an AI office because it keeps the right kind of work in the right hands. It also reduces the risk of over-mocking, brittle assertions, and false confidence in areas where a test suite cannot capture the full experience.
10Conclusion: build systems that test the machine, then use people to judge the taste
The main lesson is straightforward: unit tests are for measurable behavior, not subjective taste. They are best when they test one thing, isolate dependencies, and confirm deterministic outputs. They are less useful when the question is whether something feels good, fits the product, or reflects the right judgment.
So the best teams do both: they automate the machine and rely on people for taste. In a human + AI workspace like [this platform](https://this platform.com/), that division of labor is especially useful. AI agents can check the repeatable parts, while humans make the final call on quality and fit.
That is how you build software that is correct and coherent.
11Why This Trend Matters for Nonilion
This trend matters to Nonilion because it points to a bigger change: teams are moving from simple calls toward persistent, AI-supported collaboration spaces. Nonilion can bridge live presence, meeting context, avatars, and follow-up work so the trend becomes a usable workflow instead of a headline.
12Shareable Extracts
- The trend is not just "You can't unit test for taste: why the phrase matters" - it is a signal that team coordination is becoming the next competitive edge.
- Hot take: the teams that win from this shift will not be the ones with more meetings; they will be the ones with clearer shared context after every meeting.
- If you can't unit test for taste: why the phrase matters keeps moving this fast, remote teams need a workspace where conversation, presence, and follow-up stay connected.
- You can't unit test for taste The phrase "You can't unit test for taste" is a useful reminder that not every quality decision fits neatly into a unit test.
- Some parts of software are easier to check with repeatable tests, while other parts depend on judgment, context, and human preference.
13Social Hooks
- Everyone is talking about You can't unit test for taste: why the phrase matters. The overlooked part is what happens to team workflows after the headline fades.
- The uncomfortable question behind You can't unit test for taste: why the phrase matters: are teams adapting their collaboration systems fast enough?
- This is not a meeting trend. It is a coordination trend, and products like Nonilion sit right in the middle of that shift.
14Sources and Author
Sources
-
Explain Unit Testing like I'm five dev.to/andrewsmith1996/explain-unit-testing-like-im-five-2m3e
-
Why should unit tests test only one thing? stackoverflow.com/questions/235025/why-should-unit-tests-test-only-...
-
Lets Chat About Unit Tests www.youtube.com/watch
-
Would you say that mocking is a 'test smell' and makes unit ...
Author
This article on You can't unit test for taste was generated by the Nonilion AI blog workflow using web research inputs and AI-assisted synthesis.