From a Written Spec to a Working AI-Generated Skeleton

End-of-lesson check

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

1. What kind of work is scaffolding a new project mostly considered to be?

   1. Deeply creative architecture work
   2. Largely mechanical setup work
   3. Pure debugging
   4. Performance tuning

2. Which input does a strong scaffold prompt name precisely?

   1. The user's IDE color theme
   2. Files, exports, and module shape
   3. The maintainer's birthday
   4. The current weather

3. Which sentence best fits a scaffold prompt that gets useful output?

   1. 'Build me a startup.'
   2. 'Generate the file tree and stub files; each function gets a signature plus a TODO comment, no implementations.'
   3. 'Write a great codebase.'
   4. 'Surprise me with whatever framework you like.'

4. Why is asking for stubs without implementations useful at the scaffold stage?

   1. It keeps the diff reviewable and avoids premature implementation choices
   2. It makes the project run faster in production
   3. It guarantees zero bugs
   4. It removes the need to write tests later

5. Which task is AI good at when you provide an explicit module spec?

   1. Inventing your domain model from a one-liner
   2. Wiring imports between stubs that match a stated module shape
   3. Choosing your company's pricing model
   4. Picking your team's vacation policy

6. What does AI typically fail to do well for a scaffold?

   1. Generate a folder hierarchy from clear inputs
   2. Add a TODO comment to a stub
   3. Invent sound architecture from a vague one-liner
   4. Match your stated export names

7. Which decision should not be delegated to the AI during scaffolding?

   1. Filename casing inside a stated convention
   2. Bundler, target runtime, and build choices
   3. Adding a TODO comment
   4. Naming a function the spec already named

8. Why is a directory full of TODOs misleading as a measure of progress?

   1. TODOs are illegal in most languages
   2. Stubs feel like progress but no behavior is verified yet
   3. TODOs prevent git commits
   4. TODOs change file extensions

9. What signal indicates real, not cosmetic, progress on a fresh skeleton?

   1. The number of TODO comments grows
   2. The first end-to-end test passes
   3. The README gets longer
   4. The file count crosses 100

10. What is the safest order of operations when starting a new project with AI?

    1. Generate stubs, then write a spec to match them
    2. Write a spec, generate stubs, then drive an end-to-end test green
    3. Skip the spec entirely and prompt freely
    4. Write the README first and never touch code

11. Which is a sound use of stubs?

    1. Shipping them to production unchanged
    2. Using them as a checklist for the implementations that still need to happen
    3. Counting each stub as a finished feature
    4. Promising stakeholders the project is done

12. Why is naming exports in the spec so important?

    1. Export names anchor the module graph the AI must wire
    2. Export names change the function's runtime
    3. Exports affect file color in the IDE
    4. Exports rename the language being used

13. A teammate prompts: 'Make me a project.' Which problem is most likely?

    1. The model refuses to respond at all
    2. The model invents architecture, stack, and naming you did not want
    3. The model produces nothing
    4. The IDE crashes

14. Why pair stubs with explicit signatures rather than empty function bodies?

    1. Signatures act as a contract for both humans and AI to fill in later
    2. Signatures prevent any future changes
    3. Signatures make code unreadable
    4. Signatures cause type errors on purpose

15. Which mindset best fits scaffold-stage AI use?

    1. The AI's stubs are now the source of truth
    2. The stubs are a draft skeleton to be implemented and tested
    3. The stubs replace any need for code review
    4. The stubs guarantee the project will ship