what about not doing unit tests and just skipping thatr
- User
what about not doing unit tests and just skipping thatr
Assistant
That's actually a legitimate approach that some teams and projects take, though it comes with significant tradeoffs. Let me break down when this might make sense and what you'd need to do differently:
When skipping unit tests might be reasonable:
- Prototype/MVP development where you need to move extremely fast and the code will likely be thrown away
- Very small teams (1-2 developers) working on simple applications where the overhead of maintaining unit tests outweighs the benefits
- Legacy codebases that are so tightly coupled that writing unit tests would require massive refactoring
- Certain types of applications like simple CRUD apps or data pipelines where the logic is straightforward
- Time-constrained projects where you're making a conscious tradeoff between speed and long-term maintainability
What you'd need to compensate with:
If you skip unit tests, you absolutely need to be more rigorous about other types of testing:
Heavy integration testing becomes your safety net. You'd write more tests that exercise larger chunks of functionality together. This catches bugs but makes them harder to pinpoint when they occur.
Comprehensive end-to-end testing becomes critical. You need to cover all the major user workflows thoroughly since you won't have unit tests catching edge cases in individual functions.
Manual testing becomes much more important. You'll need dedicated time for exploratory testing and manual verification of features.
Code reviews need to be extremely thorough since you're not catching bugs through automated unit tests.
The downsides you'll face:
- Slower debugging - when something breaks, it's much harder to isolate where the problem is
- Fear of refactoring - without unit tests, developers become afraid to change code because they can't quickly verify they didn't break anything
- Regression bugs - you're more likely to reintroduce bugs you've already fixed
- Slower development over time - as the codebase grows, the lack of unit tests creates a drag on velocity
A middle-ground approach:
Some teams do "integration-first testing" where they write tests that cover multiple units working together, but still provide faster feedback than full E2E tests. This can be a reasonable compromise.
My honest take:
For anything beyond a throwaway prototype, skipping unit tests usually creates more problems than it solves. The upfront investment in writing unit tests pays dividends pretty quickly in most projects. But I understand there are real constraints and tradeoffs, and sometimes you have to make pragmatic decisions about where to invest your testing effort.
What's your specific situation? Are you dealing with time constraints, legacy code, or something else that's making you consider skipping unit tests?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.