AI coding: the test-first loop that makes review trivial

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-ai-coding-test-first-loop-r7a1-creators

1. Why does writing failing tests before requesting implementation make code review easier?

   1. The AI skips writing documentation because tests are already complete
   2. The AI will feel pressured to write perfect code on the first try
   3. The failing tests automatically fix themselves once implementation begins
   4. The tests create a readable contract that constrains what the implementation can do

2. What is the main risk of letting an AI write tests and implementation in the same conversation turn?

   1. The code will run too slowly to test properly
   2. The tests will use an incompatible programming language
   3. The implementation will delete the test files by accident
   4. The AI will shape both the tests and implementation to agree, potentially hiding bugs

3. In the test-first workflow, what should you ask the AI to do first when building a new feature?

   1. Write the full implementation and then debug together
   2. Write both tests and implementation simultaneously for speed
   3. Generate failing tests covering the happy path, edge cases, and error conditions
   4. Ask the AI to guess what kind of feature you might want

4. What capability of AI is most useful for generating tests from a behavior description?

   1. AI can predict which features will be popular next year
   2. AI can write code faster than humans can read it
   3. AI can automatically deploy the code to production
   4. AI can generate readable test cases that match the described behavior

5. A developer describes a feature and the AI generates tests with names like 'handles_empty_input' and 'rejects_negative_numbers'. What should the developer do next?

   1. Discard the tests and write implementation directly
   2. Ask the AI to combine the tests and implementation in one file
   3. Approve these test names and then ask for the implementation
   4. Have the AI generate more tests without reviewing the names

6. What can an AI reliably do in the test-first workflow?

   1. Iterate on implementation until provided tests pass
   2. Decide when the test suite is complete enough to ship
   3. Determine which business requirements are most important
   4. Invent meaningful tests for behavior the developer never described

7. What happens to code review in the test-first workflow once tests pass?

   1. Review collapses to reading two simple diffs
   2. Review takes longer because there are more files to check
   3. Review becomes unnecessary because the AI is always correct
   4. The AI skips review by automatically approving its own code

8. A student asks an AI to write tests for a 'sorting feature' but doesn't specify any specific behaviors. What limitation will the student likely encounter?

   1. The AI cannot invent meaningful tests for behavior that wasn't described
   2. The AI will refuse to write any tests
   3. The AI will write tests for every possible sorting algorithm
   4. The AI will ask the student for their credit card number

9. What does it mean to 'lock' the tests in the test-first workflow?

   1. Archive the tests so they cannot be modified later
   2. Put the test files in an encrypted folder
   3. Finalize the test code before requesting implementation
   4. Delete the implementation if tests fail three times

10. What is a 'contract' in the context of test-first AI coding?

    1. A set of readable test cases that specify exactly what the implementation must do
    2. A budget for how much the project will cost
    3. A legal agreement between the developer and the AI company
    4. A promise that the code will never have bugs

11. When should the human developer decide whether the test list is complete enough to ship?

    1. After reviewing the generated test names for coverage
    2. Never—the AI makes this decision
    3. Before writing any tests
    4. After the AI passes all the tests

12. What makes test-first review 'mechanical' rather than creative?

    1. The tests are written in a secret code only AI understands
    2. The implementation is already constrained to match the test contract
    3. The AI refuses to allow any human input
    4. Developers must solve complex logic puzzles

13. What type of output do tests provide that makes verification straightforward?

    1. Verifiable outputs
    2. Creative interpretations
    3. Marketing claims
    4. Ambiguous requirements

14. What is the relationship between test descriptions and implementation in the test-first workflow?

    1. Tests are written after implementation to verify it works
    2. Implementation is constrained to satisfy whatever the tests specify
    3. Tests are optional and only used when bugs are suspected
    4. Tests and implementation are written simultaneously by different AIs

15. Why is it important that test names be readable in plain English?

    1. So humans can review and question the specification before implementation begins
    2. So the code compiles correctly
    3. So the tests run faster
    4. So the AI can translate them to other languages