Device and method for creating technical document for software and program therefor

Abstract

In this method for creating a technical document necessary for development of software, efficiency by application of a generative AI model is realized. First, a device 100 receives explanation data representing the explanation of software to be developed (S201). The device 100 requests a first generative AI model to generate a plurality of use cases on the basis of the explanation data (S202), and the first generative AI model generates the use cases and transmits the same to the device 100 (S203 and S204). Next, the device 100 requests a second generative AI model to generate one or more pieces of business logic usable by a use case on the basis of said use case (S205), and the second generative AI model generates the business logic and transmits the same to the device 100 (S206 and S207). Then, the device 100 may request a third generative AI model to generate a corresponding API document (S208).

Description

Apparatus, method and program for creating technical documentation for software

[0001] The present invention relates to an apparatus, a method, and a program for creating technical documentation for software.

[0002] There are various methods for software development, and use cases are often created during the software requirements analysis stage. Here, a "use case" refers to the behavior of a system in response to input from a user interface (UI), or a description of that behavior. They are often written by business analysts, product owners, product managers, or other members of the business side who understand and can express the business requirements for the software being developed.

[0003] The created use cases are used by development team members such as system architects, technical analysts, and technical leads to create technical documentation that describes more technical details, and the necessary coding is then carried out based on the created technical documentation.

[0004] As software development involves many processes and many members, starting with customer interviews, there has always been a demand for greater efficiency. The inventors have discovered that by using generative AI models, whose capabilities have improved significantly in recent years, it is possible to achieve significant efficiency improvements, especially in the process of creating technical documentation.

[0005] The present invention was made in consideration of these points, and its objective is to achieve efficiency by applying a generative AI model to an apparatus, method, or program for creating technical documentation necessary for software development.

[0006] In this specification, "AI model" refers to a machine learning model that has been trained to be able to predict an output for an input, and "generative AI model" refers to a large-scale language model (LLM) that has been trained using text data to be able to generate an output for an input that is not included in the input.

[0007] To achieve this objective, a first aspect of the present invention is a method for creating technical documentation of software, comprising the steps of: acquiring explanatory data in which a description of the software is expressed, the explanatory data including at least one of one or more sentences and one or more images; making a first request to a first generative AI model to generate one or more use cases that occur in the software based on the explanatory data; and making a second request to a second generative AI model to generate one or more business logics corresponding to at least one of the one or more use cases.

[0008] A second aspect of the present invention is the method of the first aspect, wherein the explanatory data includes one or more images, and the one or more images include a plurality of images depicting a series of screens.

[0009] A third aspect of the present invention is the method of the first aspect, wherein the description data includes one or more images, and the one or more images include a sequence diagram showing the behavior of the software.

[0010] A fourth aspect of the present invention is the method according to any one of the first to third aspects, wherein the second request includes a business logic template having items of input, logic, and response.

[0011] In addition, a fifth aspect of the present invention is a method of any one of the first to fourth aspects, further comprising a step of making a third request to a third generative AI model to generate API documentation corresponding to at least one of the one or more business logics.

[0012] A sixth aspect of the present invention is the method of the fifth aspect, wherein the third request includes a template of an API document having items of a request type, a parameter, an endpoint, an API response code, and a response body.

[0013] A seventh aspect of the present invention is the method according to the sixth aspect, wherein the template of the API document further includes a corresponding business logic item.

[0014] An eighth aspect of the present invention is the method of the fourth aspect, wherein the second request includes an instruction to generate the input items using column names included in a database design of the software.

[0015] A ninth aspect of the present invention is the method of the sixth aspect, wherein the third request includes an instruction to generate at least one item of the parameters, the endpoint, and the response body using a column name included in a database design of the software.

[0016] Furthermore, a tenth aspect of the present invention is a method according to the eighth or ninth aspect, further comprising, before the second request and the third request, making a fourth request to a fourth generative AI model to generate a description of a database design using the one or more use cases.

[0017] Furthermore, an eleventh aspect of the present invention is a method of any one of the first to tenth aspects, further comprising the steps of transmitting at least one of the generated one or more business logics to the user terminal, and receiving modifications to the business logic from the user terminal.

[0018] Furthermore, a twelfth aspect of the present invention is the method of the eleventh aspect, further comprising a step of making a fifth request to a fifth generative AI model to modify use cases that can utilize the business logic according to the modification.

[0019] Furthermore, a thirteenth aspect of the present invention is a method according to the eleventh or twelfth aspect, further comprising a sixth request to a sixth generative AI model to modify an API document corresponding to the business logic in accordance with the modification.

[0020] Furthermore, a fourteenth aspect of the present invention is a method for creating technical documentation of software, comprising the steps of obtaining one or more use cases that occur in the software, creating instructions for generating one or more business logics corresponding to at least one of the one or more use cases, and executing a request k including the instructions on a generative AI model (k).

[0021] A fifteenth aspect of the present invention is the method of the fourteenth aspect, further comprising the step of storing the generated one or more business logics in association with the use case.

[0022] Furthermore, a sixteenth aspect of the present invention is a program for causing a computer to execute a method for creating technical documentation of software, the method including the steps of acquiring one or more use cases that occur in the software, creating instructions for generating one or more business logics corresponding to at least one of the one or more use cases, and executing a request k including the instructions to a generative AI model (k).

[0023] A seventeenth aspect of the present invention is an apparatus for creating technical documentation of software, configured to acquire one or more use cases that occur in the software, create instructions for generating one or more business logics corresponding to at least one of the one or more use cases, and execute a request k including the instructions to a generative AI model (k).

[0024] An eighteenth aspect of the present invention is a method for creating technical documentation for software, comprising the steps of obtaining one or more use cases that occur in the software, creating instructions for generating one or more API documents corresponding to at least one of the one or more use cases, and executing a request k including the instructions to a generative AI model (k).

[0025] A nineteenth aspect of the present invention is the method of the eighteenth aspect, further comprising the step of storing the generated one or more API documents in association with the use case.

[0026] Furthermore, a twentieth aspect of the present invention is the method of the eighteenth aspect, further comprising, before the request k, making a request l to a generative AI model (l) to generate a description of a database design using the one or more use cases.

[0027] A 21st aspect of the present invention is the method of the 18th aspect, further comprising the steps of obtaining a designation of an external API to be used by the software, and modifying at least one of the one or more API documents generated by the request k based on the one or more API documents of the external API.

[0028] Furthermore, a 22nd aspect of the present invention is a program for causing a computer to execute a method for creating technical documentation for software, the method including the steps of acquiring one or more use cases that occur in the software, creating instructions for generating one or more API documents corresponding to at least one of the one or more use cases, and executing a request k including the instructions to a generative AI model (k).

[0029] A 23rd aspect of the present invention is an apparatus for creating technical documentation of software, configured to acquire one or more use cases that occur in the software, create instructions for generating one or more API documents corresponding to at least one of the one or more use cases, and execute a request k including the instructions to a generative AI model (k).

[0030] Furthermore, a 24th aspect of the present invention is a method for creating technical documentation of software, comprising the steps of: acquiring one or more use cases that occur in the software; making a request k to a generative AI model (k) for at least any of the one or more use cases, requesting that the generative AI model (k) generate at least one or more business logics and one or more API documents that can be used for the use case; and making a request l to the generative AI model (l) requesting that the generative AI model (l) generate code corresponding to at least one of the generated business logics and one or more API documents.

[0031] Also, a 25th aspect of the present invention is the method described in the 24th aspect, further comprising the step of making a request m to the code management system to reflect the branch to which the generated code has been committed.

[0032] A twenty-sixth aspect of the present invention is the method according to the twenty-fifth aspect, wherein the request m is a push of the code to the code management system.

[0033] Furthermore, a 27th aspect of the present invention is a method according to the 25th or 26th aspect, further comprising the step of creating a branch name for the branch based on the use case before making the request m.

[0034] Furthermore, a 28th aspect of the present invention is the method of the 27th aspect, further comprising the step of verifying that the created branch name does not overlap with any branch names that have already been created.

[0035] In addition, a 29th aspect of the present invention is a program for causing a computer to execute a method for creating technical documentation of software, the method including the steps of: acquiring one or more use cases that occur in the software; making a request k to a generative AI model (k) for at least any of the one or more use cases, requesting that the generative AI model (k) generate at least one of one or more business logics and one or more API documents that can be used for the use case; and making a request l to the generative AI model (l) requesting that the generative AI model (l) generate code corresponding to at least one of the generated business logics and one or more API documents.

[0036] Furthermore, a 30th aspect of the present invention is an apparatus for creating technical documentation of software, which is configured to acquire one or more use cases that occur in the software, and to make a request k to a generative AI model (k) requesting that it generate, for at least one of the one or more use cases, one or more business logics and one or more API documents that can be used for the use case, and to make a request l to a generative AI model (l) requesting it to generate code corresponding to at least one of the generated one or more business logics and one or more API documents.

[0037] According to one aspect of the present invention, one or more business logics that can be used for one or more acquired use cases are generated based on at least one of the use cases, and if necessary, API documentation corresponding to at least one of the business logics is further generated by applying one or more generative AI models to automate the process, thereby significantly improving the efficiency of creating technical documentation required for software development.

[0038] 1 is a diagram showing an apparatus according to a first embodiment of the present invention; FIG. 2 is a diagram showing the flow of a method according to the first embodiment of the present invention; FIG. 3 is a diagram showing an example of a UI at the time of registration in the attendance management system according to the first embodiment of the present invention; FIG. 4 is a diagram showing an example of a UI at the time of login in the attendance management system according to the first embodiment of the present invention; FIG. 5 is a diagram showing an example of a UI at the time of check-in in the attendance management system according to the first embodiment of the present invention; FIG. 6 is a diagram showing an example of a UI at the time of check-out in the attendance management system according to the first embodiment of the present invention; FIG. 7 is a diagram showing an example of a UI at the time of viewing a timesheet in the attendance management system according to the first embodiment of the present invention; FIG. 8 is a diagram showing an example of a UI at the time of correcting a timesheet in the attendance management system according to the first embodiment of the present invention; FIG. 1 is a diagram showing an example of a prompt included as part of code for a third request requesting generation of an API document corresponding to the business logic at check-in of the attendance management system according to the first embodiment of the present invention. FIG. 2 is a diagram showing a template used for generating an API document corresponding to the business logic at check-in of the attendance management system according to the first embodiment of the present invention. FIG. 3 is a diagram showing a template used for generating an API document corresponding to the business logic at check-in of the attendance management system according to the first embodiment of the present invention. FIG. 4 is a diagram showing a template used for generating an API document corresponding to the business logic at check-in of the attendance management system according to the first embodiment of the present invention.10 is a diagram showing an example of a prompt included as part of the code for a fourth request to generate a database design for the attendance management system according to the second embodiment of the present invention. FIG. 11 is a diagram showing the flow of pushes for each use case to the code management system according to the fourth embodiment of the present invention.

[0039] Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.

[0040] (First Embodiment) Figure 1 shows an apparatus according to a first embodiment of the present invention. The apparatus 100 communicates with a user terminal 110 used by a user and a platform 120 that provides a generative AI model via an IP network such as the Internet to create technical documentation necessary for software development. The generative AI model will be described as being provided by the platform 120 that can communicate with the apparatus 100, but it is also possible to run an application for providing the generative AI model on the apparatus 100 so that the generative AI model is provided by the apparatus 100.

[0041] The device 100 includes a communication unit 101 such as a communication interface, a processing unit 102 such as a processor or CPU, and a storage unit 103 including a storage device or storage medium such as a memory or hard disk, and can be configured by executing a program for performing each process or operation in the processing unit 102. The device 100 may include one or more devices, computers, or servers. The program may include one or more programs, and may be recorded on a computer-readable storage medium to form a non-transitory program product. The program may be stored in a storage device or storage medium such as the storage unit 103 or a database 104 accessible from the device 100 via an IP network, and instructions included in the program may be executed by at least one processor of the processing unit 102. Data described below as being stored in the storage unit 103 may actually be stored in a storage device or storage medium such as the database 104, and vice versa.

[0042] First, the device 100 receives explanatory data that describes the software to be developed (S201). The explanatory data includes at least one of one or more sentences and one or more images. The one or more sentences may include one or more sentences describing the intended use, operating procedures, etc. of the software. Here, the explanation has been given assuming that the explanatory data is received by the device 100, but it is sufficient if the device 100 can ultimately acquire the explanatory data. As an example, the device 100 may receive a video about the software to be developed and analyze it to acquire the explanatory data. Alternatively, the device 100 may receive input through a text or audio chat dialogue with an AI model and process the input as necessary to acquire the explanatory data.

[0043] Next, the device 100 generates a natural language description of multiple use cases occurring in the software based on the description data. The following description mainly focuses on an example in which the device 100 receives, as description data, multiple images depicting a series of screens, such as those shown in Figures 3A to 3F. In this case, the device 100 can generate use cases in which each screen serves as a UI. Examples of images included in the description data include GUIs, as well as sequence diagrams showing software behavior. The description data may also include one or more pieces of text associated with one or more UI components included in the images included in the description data. If an API call occurs in response to selection of a UI component, the text associated with the UI component may include the endpoint of the API. If the UI component is an icon, the text associated with the icon may include the location of the icon.

[0044] More specifically, use case generation can be performed, for example, by the device 100 requesting (also referred to as a "first request") a generative AI model (also referred to as a "first generative AI model") to generate multiple use cases based on the description data (S202), the first generative AI model generating multiple use cases (S203), and transmitting the generated multiple use cases to the device 100 (S204). While FIG. 2 illustrates an example in which multiple use cases are generated, depending on the content of the description data, only one use case may be generated. Furthermore, if the description data itself describes one or more use cases in natural language, the use case generation process may not be performed. Furthermore, if the description data itself describes one or more use cases in natural language, the use cases may be regenerated based on the description data.

[0045] Before making the first request, device 100 may determine one or more data formats of the acquired explanatory data, and include in the first request instructions to the first generative AI model according to the determination result. The instructions, also called prompts, are used as input by the first generative AI model to generate output. Specifically, the first request may include different prompts depending on whether the explanatory data is in text format, image format, or both.

[0046] FIG. 4 illustrates an example of a use case generated by the first AI model according to the first embodiment of the present invention. The generated use case can be viewed by transmitting use case viewing screen display information, or more simply, use case display information, from the device 100 to the user terminal 110 as, for example, an HTML file and then viewing the use case viewing screen 400 displayed on a web browser on the display screen of the user terminal 110. Alternatively, an application installed on the user terminal 110 can be run and the received use case display information can be used to view the use case viewing screen 400 displayed within the application. The generated use case may also be output to a command line prompt on the user terminal 110. Note that the "viewing screen" can take various forms, such as a web page, modal window, or pop-up window, when displayed on a web browser. When displayed within an application, it can be a single screen of the application. In either case, any screen that includes an area for displaying the generated use case in a viewable manner is considered a viewing screen. Similar techniques can also be applied to other screens mentioned in this specification. Although not illustrated here, the use case viewing screen 400 can be editable.

[0047] The use case displayed on screen 400 in FIG. 4 is a natural-language description of the check-in behavior of a time attendance management system that provides the UIs shown in FIGS. 3A to 3F and corresponds to the UI shown in FIG. 3C. A use case includes an actor and a flow as items, and may further include at least one of a precondition and a postcondition. In use case 400 shown in FIG. 4, the actor is an employee, the precondition is that the employee must be logged in to the time attendance management system, and the postcondition is that the employee's attendance is recorded on the current date. Use case 400 also describes a flow, i.e., a series of system behaviors. Specifically, when an employee clicks the "Check-in" button, the system verifies the employee's identity, records the employee's attendance, and displays a confirmation message. If the verification fails, an error message is displayed. Use case 400 also describes three alternative flows. While the check-in use case has been described here, the first AI model can generate use cases corresponding to each of the UIs shown in FIGS. 3A to 3F.

[0048] Next, for each of the generated use cases, the device 100 generates one or more business logics that can be used for the use case. Here, "business logic" refers to logic for processing data sent or received through communication with the UI based on business requirements. Here, "logic" refers to a series of instructions.

[0049] More specifically, as an example, business logic generation can be performed by the device 100 making a request (also referred to as a "second request") to a generative AI model (also referred to as a "second generative AI model") to generate one or more business logics usable for a use case based on the use case (S205), the second generative AI model generating one or more business logics (S206), and transmitting the generated one or more business logics to the device 100 (S207). Although the above processing has been described for each of the generated multiple use cases, there is also the case where one or more business logics are generated for at least one of the generated multiple use cases, as in the example shown in FIG. 2.

[0050] 5 shows an example of business logic generated by the second generative AI model according to the first embodiment of the present invention. The generated business logic can be viewed on a business logic viewing screen 500 displayed on the display screen of the user terminal 110 by transmitting business logic viewing screen display information, or more simply, business logic display information, from the device 100 to the user terminal 110 in the same manner as a use case. Although not shown here, the business logic viewing screen 500 can be editable.

[0051] The business logic shown in screen 500 of Fig. 5 corresponds to the use case shown in Fig. 4. The business logic includes, as one item, logic, which is a series of instructions, and may further explicitly include at least one of the items of input and response.

[0052] FIG. 6 shows an example of an instruction called a prompt included as part of the code for a second request to a second generative AI model according to the first embodiment of the present invention. In the prompt, a use case for which one or more business logics to be generated can be used is set in the variable {use_case} as context. The prompt can also set a template (see FIG. 7 ) for one or more business logics to be generated in the variable {response_example} as context. The template includes logic, which is a series of instructions, as one item and may further explicitly include at least one of input and response items. The prompt can also set a database design in the variable {database_design} as context, which will be described in detail in the second embodiment.

[0053] The example in Figure 6 is an example of a prompt written in natural language that is included as part of code written in the programming language TypeScript. Executing this code can call the OpenAI API and generate one or more business logics that can be used for a use case set in a second generative AI model provided on the platform 120. The OpenAI API is an example, and other APIs may be used. The programming language TypeScript is an example, and other languages ​​may be used. The code for making the second request is stored in the storage unit 103, and the device 100 retrieves the code and executes it, including instructions obtained by setting required values ​​to variables included in the code. Although no specific example of a first request to a first generative AI model is provided, those skilled in the art will be able to fully understand the implementation of the first request based on the description of the second request to a second generative AI model.

[0054] While Figure 2 distinguishes between the first and second generative AI models, they may be the same generative AI model. While LLMs incorporating the Transformer architecture are particularly preferred as generative AI models, the name of the architecture is expected to change as technology advances. Therefore, in this specification, "Transformer architecture" encompasses architectures that utilize one or more features of the Transformer architecture or improvements thereof. Whether "generative AI models" are the same in this specification is determined by whether the types of generative AI models specified by the user are the same. In the Open AI API example, the same value for the variable "model" indicates that the generative AI models are the same. If the first and second generative AI models are not the same, they may be provided on the same platform 120. In the example of Figure 2, a second request is made after the first request. If the first and second generative AI models are the same generative AI model or are provided on the same platform, these requests may be made with a single API call. It should also be understood that the first and second requests may each include multiple requests, and may include one or more processes performed by the device 100 other than a request for a generative AI model.

[0055] If the set use case is long and the length of the instructions to the second generative AI model included in the second request exceeds the upper limit set for the second generative AI model, a summary of the use case can be generated from the generative AI model provided on platform 120 or another platform, and the obtained summary can be set as the variable {use_case} to make the second request. In this way, the data set in the variable {use_case} may be data corresponding to the use case. For example, one or more pieces of data generated based on the use case may be set as the variable, so that one or more business logics can be generated in smaller units rather than in units of use cases. Examples of such units include tickets or tasks used in a ticket management system.

[0056] Next, for each of the one or more business logics generated, the device 100 generates API documentation corresponding to each business logic as needed. Here, "API documentation" refers to a document that describes the API functions and usage methods.

[0057] More specifically, as an example, API documentation generation can be performed by the device 100 requesting (also referred to as a "third request") the generation AI model (also referred to as a "third generation AI model") to generate API documentation corresponding to each of the one or more generated business logics (S208), the third generation AI model generating the API documentation (S209), and transmitting the generated API documentation to the device 100 (S210). As in the example shown in FIG. 2 , the above processing is performed for each of the one or more generated business logics. However, one or more API documentation may also be generated for at least one of the generated business logics. Furthermore, one or more API documentation may also be generated corresponding to all or part of the one or more generated business logics.

[0058] FIG. 8 shows an example of an API document according to the first embodiment of the present invention. The API document displayed on screen 800 in FIG. 8 includes fields such as a request type, parameters, an endpoint, an API response code, and a response body, and may further include at least one of validation, authentication, authorization, and a request body. Although not shown in FIG. 8 due to space limitations, the API document preferably includes one or more business logics corresponding to the API document, as shown in FIG. 10C. This allows the user to understand which business logics the API described in the API document can be used to implement. A single API may be usable for multiple business logics.

[0059] The API documentation can be viewed, for example, on an API documentation viewing screen 800 displayed on the display screen of the user terminal 110 by sending API documentation viewing screen display information, or more simply, API documentation display information, from the device 100 to the user terminal 110 in the same manner as a use case. In this case, it is preferable that the response body be described in the API documentation display information so that it can be displayed in JSON format. Although not shown here, the API documentation viewing screen 800 can also be made editable.

[0060] FIG. 9 shows an example of a prompt written in natural language that is included as part of a third request to the third generative AI model according to the first embodiment of the present invention. In the prompt, one or more business logics corresponding to one or more API documents to be generated can be set as context in the variable {business_logics}. Alternatively, one or more pieces of data generated based on the business logic can be set as variables, so that one or more API documents can be generated in smaller units rather than business logic units. Furthermore, in the prompt, a template for the API document to be generated can be set as context in the variable {response_example}. Items that can be included in such a template are as described above. In the example of FIG. 9, in addition to the business logic, a value is also set as context in the variable for a use case in which the business logic can be used. However, if business logic is given, it is possible to have the third generative AI model generate corresponding API documents. In the prompt, a database design can also be set as context in the variable {database_design}, as will be described in the second embodiment.

[0061] The example in FIG. 9 shows a portion of code written in the programming language TypeScript. By executing this code, the OpenAI API can be invoked to generate one or more API documents corresponding to the business logic set in the third generative AI model provided on the platform 120. The OpenAI API is an example, and other APIs may be used. The TypeScript programming language is an example, and other languages ​​may be used. The code for making the third request is stored in the storage unit 103, and the device 100 acquires the code and executes it, including instructions obtained by setting required values ​​to variables included in the code. In this example, one or more API documents corresponding to the set business logic are generated. However, one or more corresponding API documents may also be generated by setting a use case or one or more pieces of data generated based on the use case as variables.

[0062] While Figure 2 illustrates a case in which the third generative AI model is identical to the second generative AI model, these may be different generative AI models. If the second and third generative AI models are not identical, they may be provided on the same platform 120. In the example of Figure 2, the third request is made after the second request. If the second and third generative AI models are the same generative AI model or provided on the same platform, these requests may be made by a single call to the API. Furthermore, the third request may include multiple requests and may include one or more processes performed by the device 100 other than the request for the third generative AI model.

[0063] The device 100 may receive or acquire a designation of an external API to be used in the software. The designation may be, for example, the name of the external API or one or more URLs of one or more API documents for the external API. When an external API is designated, the device 100 may acquire one or more API documents for the external API and store them in association with the software. For example, based on the one or more API documents for the external API stored in this manner, the device 100 may modify, replace, or otherwise change at least one of the one or more API documents generated by the third request so that the external API can be successfully invoked.

[0064] The device 100 may receive the one or more generated use cases and technical documentation generated using these use cases, and transmit them to the user terminal 110 (S211). As a specific example, the technical documentation includes the one or more generated business logics and one or more API documents corresponding thereto.

[0065] As described above, by applying one or more generative AI models to automate the process of generating one or more business logics that can be used for one or more acquired use cases based on at least one of the use cases, and further generating API documentation corresponding to at least one of the business logics as needed, the creation of technical documentation required for software development can be significantly made more efficient.

[0066] Before proceeding to generate business logic using a use case, the use case may be validated. For example, the validation may be to verify that the use case satisfies the conditions required for generating business logic using the use case. Similarly, before proceeding to create API documentation using the business logic, the business logic may be validated.

[0067] Second Embodiment As in the prompt examples of FIGS. 6 and 9 described in the first embodiment, a description of the database design may be set as the variable {database_design} as the context. In this case, as in the example of FIG. 6, an instruction to determine input items included in the business logic using column names included in the database design can be included in the second request. This allows business logic consistent with the database design to be obtained. Furthermore, an instruction to determine terms included in at least one of the actors, flows, preconditions, and postconditions included in the use case using column names included in the database design can be included in the first request. Alternatively, as in the example of FIG. 9, an instruction to determine at least one of the parameters, endpoints, validations, request body, and response body included in the API document using column names included in the database design can be included in the third request.

[0068] The database design description may be acquired by device 100 receiving it from user terminal 110, or may be generated by a generative AI model based on one or more use cases generated or acquired by device 100. More specifically, device 100 may request (also referred to as a "fourth request") a generative AI model (also referred to as a "fourth generative AI model") to generate a database design based on one or more use cases. Before proceeding to generate a database design based on one or more use cases, the one or more use cases may be verified. The verification may, for example, verify that the one or more use cases satisfy conditions necessary for generating a database design based on the one or more use cases. Furthermore, the fourth request may include multiple requests and may include one or more processes performed by device 100 other than the request to the fourth generative AI model.

[0069] The fourth request, like the second and third requests, can be made by preparing code in advance and having device 100 execute the code containing instructions obtained by setting the necessary variables. The fourth generative AI model may be the same as or provided on the same platform or device as at least one of the first to third generative AI models. Naturally, if the variable {database_design} is set in the second and third requests, the fourth request must be executed before the second and third requests.

[0070] FIG. 11 shows an example of a prompt written in natural language that is included as part of the code for the fourth request for generating a database design description for the attendance management system according to the second embodiment of the present invention. In this prompt, one or more use cases are set in the variable {use_case} as context, and one or more tables created so far are set in the variable {previous_tables}. In addition, in this prompt, data identifying one or more APIs whose API documentation was generated from one or more use cases set in the variable {use_case} is set in the variable {apis}, improving the accuracy of creating at least one new table, column, and relationship. The variable {use_case} may be set to data corresponding to the use case rather than the use case itself. For example, a use case may be analyzed to extract one or more tables and relationships between the tables required for the use case, and then set in this variable. While an example of an ERD is shown here, the present invention is not limited to ERDs.

[0071] (Third Embodiment) The technical document transmitted to the user terminal 110 can be displayed in an editable format on the display screen of the user terminal 110, allowing the user of the user terminal 110 to make modifications (S212). The modifications are then transmitted from the user terminal 110 to the device 100, which can then request (also referred to as a "fifth request") a generative AI model (also referred to as a "fifth generative AI model") to modify at least one use case in accordance with the modifications. More specifically, if a user modifies a certain business logic, the fifth request can be a request to modify a use case that can use the business logic (S213).

[0072] Generally, use cases are created by business members and technical documentation is created by development members, so it is not easy to maintain consistency between the use cases and the technical documentation based on them. By modifying the use cases according to this embodiment, it becomes possible to maintain consistency between the two.

[0073] When a modification is made to the business logic, in addition to or instead of modifying the use case, a request (also referred to as the "sixth request") can be made to the generative AI model (also referred to as the "sixth generative AI model") to modify the API document corresponding to the business logic.

[0074] The fifth and sixth requests, like the second and third requests, can be made by preparing code in advance and having device 100 set the necessary variables and execute it. The fifth and sixth generative AI models may be the same as or provided on the same platform or device as at least one of the first to third generative AI models. Furthermore, the fifth and sixth requests may each include multiple requests, and may include one or more processes performed by device 100 other than requests for generative AI models.

[0075] Fourth Embodiment The device 100 generates, for all or part of one or more acquired use cases, at least one of one or more business logics and one or more API documents that can be used for the use cases using a generative AI model, and can further generate code corresponding to the generated technical documents using the generative AI model. Figure 12 shows this flow (S1201 to S1207).

[0076] In FIG. 12 , use case generation, technical documentation generation, and code generation are illustrated as being performed by requests to the first, second, and third generative AI models, respectively. However, these generative AI models may be the same generative AI model, different generative AI models provided on the same platform 120, or different generative AI models provided on different platforms. Furthermore, technical documentation may be generated by generating business logic and API documentation separately, as in the above-described embodiment. If multiple generative AI models are the same generative AI model or provided on the same platform, requests to these generative AI models may be made by a single API call. Furthermore, a request to each generative AI model may include multiple requests and may include one or more processes performed by the device 100 other than the request to the generative AI model. A request to each generative AI model can be made by preparing code in advance and having the device 100 execute the code containing instructions created by setting the necessary variables.

[0077] The device 100 that has acquired the generated code can create a branch to commit the code using a branch name that corresponds to the use case to which the code corresponds (S1208). The device 100 may then verify, as necessary, that the created branch name does not overlap with any branch names that have already been created. This ensures that branches are separated for each use case. While FIG. 12 shows that the device 100 creates the branch name, the device 100 may also request creation from an external device. To create a branch with the branch name {branch_name}, for example, the following command may be used: git branch {branch_name}

[0078] Next, the device 100 switches to the created branch and commits the generated code (S1209). While FIG. 12 shows the generated code being committed all at once, it may be divided into coherent parts and committed multiple times. The commit message that can be specified for each commit can also be generated by a request from the device 100 to the generative AI model depending on the changes to be committed. The branch name described above can also be generated by a request from the device 100 to the generative AI model depending on the use case.

[0079] The device 100 then requests the code management system 130, which can communicate via an IP network such as the Internet, to reflect the generated code in the committed branch (S1210). Specifically, when using git, the request is a push to the code management system, and for example, the following command can be used: git push -u origin {branch_name}

[0080] In this way, by creating a branch locally using a branch name that corresponds to the use case and pushing it to the remote repository, it becomes possible to manage the code required for the software being developed on a use case basis.

[0081] The explanation of this embodiment so far has been based on use cases, but as explained in the first embodiment, it is also possible to generate multiple pieces of data in predetermined units such as tickets and tasks based on use cases, generate technical documents and corresponding code for these data units, and manage branches into which the generated code is committed in the code management system 130. In this case, branch names are created and specified according to each of the multiple pieces of data generated based on a use case.

[0082] Additionally, the device 100 can request a pull request for the pushed branch from the code management system 130 (S1211), and cause the code management system 130 to execute the pull request (S1212).

[0083] It should be noted that in the above embodiments, unless the word "only" is used, such as "based only on," "only in response to," "only in the case of," or "with reference only," this specification assumes that additional information may be taken into consideration. Also, as an example, it should be noted that the phrase "do b when a" does not necessarily mean "do b always when a" or "do b immediately after a" unless explicitly stated otherwise. Furthermore, the phrase "each a constituting A" does not necessarily mean that A is composed of multiple components, but includes the case where the component is singular.

[0084] Also, just to be clear, even if there is an aspect of a method, program, terminal, device, server, or system (hereinafter referred to as a "method, etc.") that performs an operation different from that described in this specification, each aspect of the present invention is directed to an operation that is identical to one of the operations described in this specification, and the existence of an operation different from that described in this specification does not make the method, etc. outside the scope of each aspect of the present invention.

[0085] It should be noted that the disclosure of this specification includes any combination of the above-described embodiments of the present invention within the scope of not contradicting each other.

[0086] Furthermore, while the above description refers to multiple generative AI models, for example, in the second embodiment, there are cases where a request needs to be made to the fourth AI model before making a request to the second and third generative AI models. In such cases, from the standpoint of readability, the fourth AI model may be referred to as "AI model (k)," the second AI model as "AI model (l)," and the third AI model as "AI model (m)." In other cases, similar appropriate interpretations may be used.

[0087] 100 Device 101 Communication unit 102 Processing unit 103 Storage unit 104 Database 110 User terminal 120 Platform 130 Code management system 400 Use case viewing screen 500 Business logic viewing screen 800 API document viewing screen

Claims

1. A method for creating technical documentation of software, comprising: obtaining one or more use cases that occur in the software; creating, for at least one of the one or more use cases, instructions for generating at least one of one or more business logics and one or more API documents corresponding to the use case or smaller units of data generated based on the use case; and executing a request k including the instructions to a generative AI model (k).

2. The method of claim 1, further comprising the step of storing at least one of the generated business logic(s) and one or more API documents in association with the use case.

3. A method according to claim 1 or 2, further comprising, prior to said request k, making a request l to a generative AI model (l) to generate a description of a database design using said one or more use cases.

4. The method of claim 3, wherein the request includes an instruction to use column names contained in the database design.

5. A method according to claim 1 or 2, further comprising the steps of: obtaining a designation of an external API to be used in the software; and modifying the API documentation generated by the request k based on one or more API documentation of the external API.

6. A method according to any one of claims 1 to 5, further comprising the step of making a request l to a generative AI model (l) requesting it to generate code corresponding to at least one of the generated one or more business logics and one or more API documents.

7. The method according to claim 6, further comprising the step of making a request m to the code management system to reflect the branch to which the generated code has been committed.

8. The method of claim 7, wherein the request m is a push of the code to the code management system.

9. A program for causing a computer to execute a method for creating technical documentation of software, the method comprising: acquiring one or more use cases occurring in the software; for at least one of the one or more use cases, creating instructions to generate at least one of one or more business logics and one or more API documents corresponding to the use case or smaller units of data generated based on the use case; and executing a request k including the instructions to a generative AI model (k).

10. An apparatus for creating technical documentation of software, configured to obtain one or more use cases occurring in the software, and for at least one of the one or more use cases, create instructions for generating at least one of one or more business logics and one or more API documents corresponding to the use case or smaller units of data generated based on the use case, and execute a request k including the instructions to a generative AI model (k).

Images