Development is the iterative creation of something new and useful.
When we think of development, new product development often comes to mind. This differs from manufacturing, which produces individual products; instead, it involves creating the design specifications or molds for products.
Thus, the blueprints or molds created through new product development are repeatedly used in factories to manufacture numerous identical products.
There are also uses like developing individual abilities or developing society and nations. These imply not merely an increase in what one possesses, but the ability to repeatedly use and benefit from the developed capabilities.
While the economic power of individuals and societies may fluctuate due to economic conditions, developed capabilities are fundamentally permanent.
Even if they decrease, it is considered decline rather than the up-and-down fluctuations of economic prosperity.
Beyond these, there is also the development of technology and knowledge. Unlike the capabilities of individuals or specific societies, these have the characteristic of being easily shareable.
And among the products, capabilities, knowledge, and technologies that are the outcomes of these developments, some can contribute to subsequent development.
By developing such useful outputs, the scope of development broadens, and efficiency and quality improve.
AI-Driven Software Development
Generally, development has required significant time and effort. Especially as society advances and various things become more sophisticated, creating new things becomes even more difficult.
However, with the advent of generative AI, this situation is changing. Currently, software development is undergoing dramatic changes thanks to the high programming capabilities of generative AI.
In this landscape, a future vision where autonomous agents based on generative AI become central to software development as software engineers is already becoming a reality.
We are currently in a transitional phase. While we cannot fully entrust development to generative AI, skillfully utilizing generative AI can powerfully advance software development.
This is referred to as AI-driven software development.
Developmental Development
When generative AI makes software development more efficient, it can streamline not only the development of the final target software but also the development of software that aids in development itself.
As mentioned earlier, outputs that facilitate development broaden its scope, and help improve efficiency and quality. Moreover, if created effectively, they can be reused in other development projects.
Therefore, by developing software that aids in development during the software development process, overall efficiency can be increased, and these assets can be leveraged for future development.
Conventionally, developing such auxiliary software was common practice, but it required its own development time and effort, necessitating careful consideration and focused execution.
By utilizing generative AI, one can quickly create simple software to automate minor tasks that come to mind. If the task involves clear processing, generative AI can accurately generate the program with almost no errors.
Consequently, developing software to assist in development during the software development process has become easier than before.
And, by thinking deeply about this, a development style emerges where useful tools for development are continuously created during the process, thereby transforming the development methodology itself.
We will call this "developmental development."
To practice developmental development, one needs the habit of objectively observing their own software development, considering which parts can be handled by software and which parts only by humans, along with the skill to develop such auxiliary software.
Furthermore, generative AI can be incorporated into these software tools. By embedding it within the software, unlike generative AI agents, the scope of processing can be narrowed to some extent, and pathways can be defined.
While AI agents can achieve similar results through prompts, software with embedded generative AI can more easily increase accuracy by combining both programs and prompts.
If such developmental development can be practiced, the second project will show improvements in both quality and cost compared to the first. Furthermore, with each subsequent project—the third, fourth, and so on—improvements will continue to accrue.
This is entirely different from merely using generative AI to develop software. A significant gap will emerge over time between teams that simply master generative AI tools and teams that practice developmental development.
Refactoring-Driven Testing
There's a concept called Test-Driven Development (TDD), where tests are designed first based on specifications, and then software is developed to pass those tests.
Initially, I also thought that by leveraging generative AI, it would be easy to develop test programs for automated testing, making TDD feasible.
However, as I began practicing developmental development, I came to believe that thinking about tests before implementing them isn't always the most suitable approach.
Especially for software like web applications that involve subjective aspects such as usability and visual design, which one interacts with directly, I realized that actually running and interacting with the software takes precedence over detailed tests.
This is because if there's significant dissatisfaction at the UI/UX level after interacting with it, there's a possibility of wanting to change fundamental parts like the framework, basic architecture, data model, or use cases.
In my current personal software development project, I noticed issues with feature flexibility and performance and ended up swapping out two frameworks for different ones.
I also had to completely review processing in some areas due to inefficient memory usage.
It is at these moments of refactoring that testing first becomes a conscious consideration.
If this is at an early stage of development, or if the functions and specifications are going to change significantly anyway, tests might be unnecessary.
However, if development is already quite advanced and there are many items to check, tests will be necessary to confirm that refactoring has not introduced functional defects or omissions.
Therefore, the approach of creating test programs when development has progressed to a certain extent and refactoring becomes necessary is not a bad idea.
At this point, the key is not to create tests for all code, but to focus on testing mature parts that are unlikely to change much in the future, while leaving fluid parts without automated tests.
This can be called Refactoring-Driven Testing.
Conclusion
Generative AI is dramatically transforming software development.
In a previous article, I wrote about the importance of aiming to be an "Omni-directional Engineer," capable of developing systems that combine various domains, infrastructures, and execution environments, going beyond the traditional full-stack engineer.
I also wrote an article suggesting that we are entering an era of "Experience & Behavior-centric Development," where the focus is not on aligning specifications with implementation, but on improving user experience through software behavior.
Developmental development and refactoring-driven testing are precisely what lead to these new horizons in software development.