&gt; Unit tests are usually too low-level to give feedback into the API design. My experience is that functional tests, based on use case scenarios, give much better feedback.<p>I was talking about the API of the unit under test. In JavaScript terms, this typically means the public API of the module being tested. APIs are developer UX, and providing a good developer UX is great for code quality.<p>&gt; Standard TDD-based design doesn&#x27;t really have a way to specify which is part of the &quot;public&quot; API vs. the testing API.<p>You should only test the module&#x27;s public API. If there are functions used internally by that module that also need testing, those bits should be in their own modules with their own unit tests.<p>&gt; Unit tests rarely encode performance requirements.<p>Correct, but mostly because the biggest perf problems don&#x27;t happen at the unit level. They happen at integration levels where things like network communications and disk access happen. Unit tests document the unit&#x27;s requirements, not the app&#x27;s requirements. That&#x27;s why it&#x27;s also important to have functional tests, and depending on needs, integration tests as well, but even those usually don&#x27;t measure perf. That&#x27;s where load testing and app profiling come into play.<p>All of that is important, and I&#x27;m not trying to downplay any of that. However, none of those things can replace unit tests, and the benefits of documenting unit functionality in code.<p>&gt; Manual QA is a skill in it own right. This is why you have QA staff<p>Agreed, but it would be extremely inefficient for a developer to ask the QA team for help testing every time they make a change to a unit under development. Automating unit-level QA can solve time by automatically checking the full behavior suite of the unit under test every time the developer saves a file. Studies have shown that far fewer errors make it into the released product when developers use a TDD process, which saves developer time, saves QA time, and improves the user experience, because there are fewer product defects.<p>&gt; You’ll probably get better return on your investment by automating integration tests, bug regression tests, and system tests than by automating unit tests.<p>That&#x27;s one person&#x27;s opinion. The empirical evidence linked to in the article says otherwise.<p>In the article you refer to, James Coplien betrays his misunderstanding about the ideal role and use of unit tests by talking about refactoring already existing functions into smaller, more testable functions. Using the TDD process (test first), you write the assertions before you implement the functions, so no such refactoring is necessary.<p>He also talks about the futility of large code coverage from the perspective of somebody going back over code and adding tests later, which can indeed be quite challenging, but if you&#x27;re following TDD, you don&#x27;t write code paths that do not satisfy a test assertion, which guarantees 100% code coverage.<p>It would be silly to throw out a process that has been tried and proven because of the opinion of somebody who doesn&#x27;t even understand the process to begin with. =)