Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-v3-0324· DeepSeekHugging Face LMArena Human Preference 140K

what about not doing unit tests and just skipping thatr

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514’s answer.
  1. User

    what about not doing unit tests and just skipping thatr

  2. DeepSeek Assistant

    Skipping unit tests entirely is a risky decision that can lead to serious problems in the long run. While it might seem tempting (especially under tight deadlines), here’s why it’s a bad idea—and what you could do instead if you really can’t write them.


    Why Skipping Unit Tests is a Bad Idea

    1. Bugs Multiply in the Dark

      • Unit tests catch small issues early before they snowball into bigger problems.
      • Without them, bugs often surface later in integration or E2E tests (or worse, in production), making them harder and more expensive to fix.
    2. Refactoring Becomes Dangerous

      • Without unit tests, changing code is like walking on a tightrope without a safety net.
      • Even small changes can break things in unexpected ways, and you won’t know until much later.
    3. Slower Debugging

      • When something fails in an E2E test, you have to trace the problem through multiple layers.
      • Unit tests help isolate failures to a single function or class, making debugging faster.
    4. Poor Code Design

      • Writing unit tests forces you to think about modular, decoupled code.
      • Skipping them often leads to tightly coupled, hard-to-maintain spaghetti code.
    5. False Confidence from Other Tests

      • Integration/E2E tests are slower, flakier, and cover less code.
      • You might think you’re well-tested, but critical logic could be completely untested.

    When You Might Get Away With Fewer Unit Tests

    If you absolutely can’t write unit tests (e.g., legacy code, extreme time pressure), here are some mitigations:

    ✅ Focus on Integration Tests

    • Test critical workflows end-to-end (e.g., API calls, database interactions).
    • Tools: Postman, Cypress, Selenium, API automation frameworks.

    ✅ Use Contract Testing (for Microservices)

    • Instead of unit-testing every service, define and test contracts between them.
    • Tools: Pact, Spring Cloud Contract.

    ✅ Manual Testing (Temporarily)

    • If automation isn’t possible, at least manually test core features before release.
    • But: This doesn’t scale and is error-prone.

    ✅ Static Analysis & Linting

    • Use tools to catch bugs before runtime (e.g., ESLint, SonarQube, PyLint).

    ✅ Observability Over Testing

    • If you can’t test well, at least monitor aggressively in production.
    • Logs, metrics, and distributed tracing (e.g., Prometheus, OpenTelemetry) can help catch issues early.

    The Reality: You’ll Pay Later

    Skipping unit tests might save time now, but it always costs more later in:

    • Bug fixes (harder to diagnose without unit tests)
    • Technical debt (messy, untested code becomes unmaintainable)
    • Slower development (fear of breaking things slows down changes)

    Final Advice

    If you must skip unit tests:

    1. At least test the most critical logic (e.g., payment processing, security checks).
    2. Compensate with strong integration/E2E tests.
    3. Plan to add unit tests later (technical debt isn’t free).

    But if you can, just write the damn unit tests. They save time in the long run. 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.