Software development differs significantly from traditional assembly line processes. While engineering disciplines rely on a clear separation between design and execution, software development is inherently dynamic. Design often evolves through coding, requiring constant interaction among developers, product owners, and users. The author emphasizes that large language models (LLMs) risk reinforcing the outdated assembly line metaphor by suggesting that code generation can occur in isolation. Instead, LLMs should be viewed as brainstorming partners that assist in the learning process rather than as substitutes for hands-on engagement in software creation. The author outlines a learning loop fundamental to software development: observe and understand, experiment and try, recall and apply. Each step is critical for deepening knowledge and fostering skill development. While LLMs can ease initial setup hurdles by generating boilerplate code or suggesting dependencies, they can't replace the experiential learning that comes from grappling with challenges. Failures and breakthroughs in coding are essential learning moments that contribute to lasting expertise. The article critiques the allure of low-code platforms and starter kits. While they provide speed and convenience for standard use cases, they come with hidden costs. By relying on pre-built components, developers miss out on internalizing the underlying principles and context. The author warns that this lack of understanding can lead to inefficiencies, much like software systems that experience performance drops when faced with unexpected requirements. True learning is a continuous, adaptive process, and successful software development methodologies like Agile recognize this.