In agile and modern software development practices, what does TDD (Test Driven Development) emphasize as the first major step in the coding cycle?

Introduction / Context:
Test Driven Development is a widely known software development technique associated with agile methods such as Extreme Programming. In TDD, developers write tests and code in very small, rapid cycles that encourage simple design and continuous feedback. This question focuses on the central idea of TDD and asks what activity should happen first in the typical TDD loop.

Given Data / Assumptions:

• TDD stands for Test Driven Development.
• TDD uses a short cycle often described as Red, Green, Refactor.
• Automated unit tests are an essential part of this cycle.
• We assume common industry practices as described in TDD literature.

Concept / Approach:
The TDD cycle begins by writing a small test that describes a new piece of behavior and that initially fails because the functionality does not yet exist. This is the Red phase. After that, the developer writes the minimal production code required to make the test pass, which is the Green phase. Finally, the Refactor phase cleans up the code while keeping tests passing. Therefore, the first major step emphasized by TDD is writing an automated test before writing production code.

Step-by-Step Solution:
Step 1 Recall the Red, Green, Refactor mantra of Test Driven Development. Step 2 Understand that Red refers to a failing test written before any new code. Step 3 Recognize that Green refers to writing minimal code so that the test passes. Step 4 Select the option that says the process starts by writing an automated test before production code, which captures the essence of TDD.

Verification / Alternative check:
Standard TDD guides, books, and tutorials all emphasize that developers should never write production code unless they first have a failing test that justifies it. Sample TDD sessions show the developer starting by imagining how the code should behave, expressing that behavior in a test, and only then implementing the actual code. This consistent description across many sources confirms that writing the test first is the defining feature of TDD.

Why Other Options Are Wrong:
Writing all documentation before any test or code is part of more traditional methodologies and is not the main idea of TDD. Refactoring existing code without tests goes against TDD principles, which insist on having tests to support safe refactoring. Deploying to production before local testing is risky and directly contradicts quality practices. Designing the database schema after implementation is a separate design choice and not the key step in TDD.

Common Pitfalls:
Many developers say they practice TDD but still write tests after writing the code, which is actually test last development. Others confuse TDD with simply having a lot of tests, ignoring the requirement that tests drive the design from the beginning. Following the correct order, starting with tests, helps create better decoupled designs and safer refactoring opportunities.

Final Answer:
In Test Driven Development, the first major step is Writing an automated test before writing the production code.