AI coding: spec-driven prompts that compile on the first pass

End-of-lesson check

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

1. What primary trait distinguishes a spec-driven prompt from an ordinary wish-style request?

   1. It uses friendlier conversational tone
   2. It enumerates inputs, outputs, edge cases, and error behavior up front
   3. It is always shorter than five sentences
   4. It avoids naming the programming language

2. A teammate writes: 'Make a function that handles user signup.' Why is this prompt likely to produce mush?

   1. It does not specify which AI model to use
   2. It omits the typed signature, validation rules, return shape, and error modes
   3. It is too polite for the model to take seriously
   4. It uses the word 'function' which confuses LLMs

3. Which task is AI especially well suited for once you provide a typed signature?

   1. Choosing which programming paradigm your company should adopt
   2. Implementing a function exactly to the signature you provided
   3. Deciding business pricing for the resulting feature
   4. Auditing your hiring pipeline

4. Why does enumerating edge cases in the prompt boost first-pass quality?

   1. It signals to the model which branches must be implemented and tested
   2. It prevents the model from using if-statements at all
   3. It forces the model to switch to a different language
   4. It removes the need for type annotations

5. Which is something AI cannot do reliably even when you provide a thorough spec?

   1. Generate matching unit tests
   2. Implement happy-path branches
   3. Guess unstated requirements from your domain
   4. Enumerate edge cases you listed

6. What does 'spec drift' refer to?

   1. The model getting slower over time as the file grows
   2. Mid-conversation changes to requirements without restating the full spec
   3. Floating-point precision loss in numeric outputs
   4. Network latency between you and the model provider

7. Halfway through a chat you change the return type. What is the safer move?

   1. Patch only the return type and assume the model remembers the rest
   2. Restart the prompt with the full updated spec
   3. Switch to a smaller model so it forgets faster
   4. Delete the conversation history without restating anything

8. Which prompt fragment best fits a spec-driven request?

   1. 'Make it production-ready, you know what I mean.'
   2. 'parseDate(input: string) -> Date. Throws InvalidDateError on empty string. Edge cases: ISO, RFC2822, leap days.'
   3. 'Write something cool that handles dates.'
   4. 'Pick whatever date library you like and surprise me.'

9. Why does naming the error type and its trigger condition help?

   1. It lets the model invent unrelated runtime exceptions freely
   2. It pins down failure behavior so callers and tests can rely on it
   3. It forces the model to skip writing tests entirely
   4. It guarantees no errors will ever occur in production

10. Why can a vague spec lead to more total iteration than a tight one?

    1. Because the AI charges more per vague token
    2. Because each ambiguous decision becomes a re-prompt cycle to correct
    3. Because vague prompts disable streaming output
    4. Because vague prompts always crash the model

11. What is the value of asking the AI to include unit tests in the same response?

    1. Tests provide a runnable check against your stated edge cases
    2. Tests double the cost without changing quality
    3. Tests force the AI to use a slower model
    4. Tests make the function impossible to refactor later

12. Which scenario shows the limit of spec-driven prompting?

    1. An engineer lists every input, output, and error mode for a parser
    2. An engineer says 'handle all weird user data' without examples
    3. An engineer pastes a typed function signature and edge cases
    4. An engineer specifies the exception class to throw

13. A spec-driven prompt is more like which everyday document?

    1. A holiday postcard
    2. A mission statement
    3. A function signature with a docstring
    4. A motivational quote

14. Why is 'first-pass quality' a useful metric for AI coding?

    1. It rewards prompts that minimize the rework cycle after generation
    2. It measures how many emojis the model uses
    3. It favors the longest possible response
    4. It tracks how many times you switch IDE themes

15. Your AI produced code that fails a domain-specific edge case you forgot to mention. What does that mostly indicate?

    1. The model is broken and should be replaced
    2. The spec was incomplete and should be updated to include that case
    3. AI cannot ever be used for that domain
    4. Edge cases must always be discovered by users in production