Embracing Large Language Models in Software Engineering: The Right Way

1. The Wave of Large Models

ChatGPT (based on GPT‑3.5) and GPT‑4 have created a wave of excitement across all fields, and software engineering is no exception. Experts have experimented with using large models for requirement analysis, design, code generation, testing, refactoring, and defect fixing, leading to sensational claims such as "programming will end" and the notion of a new "Software Engineering 3.0" era.

2. Calm Reflection

While large models can assist with local tasks—e.g., generating code snippets or answering technical questions—the real difficulty lies in achieving end‑to‑end, systematic, generative development. The author compares this to the historical challenge of software reuse and product lines: copying code is easy, but systematic, customized development is hard. In practice, ChatGPT can generate complete, runnable programs for tiny applications such as a Tetris game when the process is broken into ten incremental tasks (framework, GUI, L‑shaped block, movement, rotation, falling, line clearing, scoring, etc.). However, these successes rely on strong prompting skills and human oversight; the model often omits important requirements or makes subtle errors.

3. Software Development Scale and Complexity

When software reaches tens of thousands or millions of lines, a human cannot keep track of the entire generation process, and large models struggle to maintain a global view. Even for modest projects, ChatGPT may “forget” earlier code (e.g., inconsistent method names or return values). Consequently, large‑scale development still requires multi‑layer decomposition, coordinated teams, and continuous communication—tasks that current models cannot replace.

4. Lack of Abstract Thinking and Precision

Designing high‑level architecture involves abstract reasoning and trade‑offs (e.g., choosing architectural styles). Large models excel at surface‑level token generation but lack the deep abstract understanding needed for such decisions. Their probabilistic nature also clashes with the precision demanded by software, leading to locally correct code (80‑90% accuracy) that still requires human verification and correction.

5. Hidden Knowledge in Requirements and Design

Much of the knowledge behind requirements and design exists only as tacit “dark knowledge” in developers’ minds, whiteboards, or meeting discussions, and is rarely captured in formal documents. Even when detailed specifications are available, they seldom record the rationale, alternatives, and trade‑offs that guided decisions, making it difficult for models trained on public corpora to learn and apply this information.

6. Long‑Term Maintenance Challenges

Enterprise software evolves over long lifecycles, undergoing requirement changes, bug fixes, and performance improvements. For intelligent development support, large models must understand existing code, map requirements to code elements, and manage the ripple effects of modifications. Moreover, generated code often contains duplicated fragments, creating maintenance burdens when consistency must be preserved.

7. Proper Way to Embrace Large Models

The author argues that the sensible approach is to first solidify the digitalization and knowledge‑base of software development—building component libraries, tracking code clones, linking design artifacts to code, and recording development tasks. Large models can then be leveraged to augment these assets, providing contextual assistance for requirement refinement, design generation, and code synthesis. A unified intelligent interaction engine, possibly built into next‑generation IDEs, should orchestrate the collaboration between developers, large models, and existing tooling (static analysis, testing, defect tracking), managing multi‑threaded conversations, context switching, and task scheduling.

Conclusion

While large language models offer undeniable productivity gains for small, well‑defined applications, achieving systematic, end‑to‑end intelligent software engineering for large systems demands substantial groundwork in digital knowledge management and a robust human‑model‑tool integration framework.