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

Abstract

To provide a device, a method and a program therefor which realize the efficiency by application of a generative AI model in a method for creating a technical document necessary for development of software.SOLUTION: In a method: a device receives, from a user terminal, explanation data representing the explanation of software to be developed S201, and requests a first generative AI model to generate a plurality of use cases on the basis of the explanation data S202; the first generative AI model generates the use cases S203 and transmits them to the device S204; the device requests a second generative AI model to generate one or more pieces of business logic usable by a use case on the basis of the use case S205; the second generative AI model generates the pieces of business logic S206 and transmits them to the device S207; and, for each of them, the device may request the second generative AI model to generate a corresponding API document S208.SELECTED DRAWING: Figure 2

Description

Technical Field

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

Background Art

[0002] There are various methods for software development, and among them, use cases are often created in the software requirements analysis stage. Here, the "use case" refers to the behavior of the system or its description in response to input from the user interface (UI), and is often described by business-side members such as business analysts, product owners, and product managers who can understand and express the business requirements for the software to be developed.

[0003] The created use cases are used by development-side members such as system architects, technical analysts, and technical leads to create technical documents with more technical details, and the necessary coding is performed based on the created technical documents.

Summary of the Invention

Problems to be Solved by the Invention

[0004] Thus, in software development, starting from customer hearings, involving many members and many processes, efficiency has always been demanded. The inventors have found that by using a generative AI model whose capabilities have been significantly improved in recent years, significant efficiency improvements can be achieved particularly in the process of creating technical documents.

[0005] The present invention has been made in view of such points, and the problem is to realize efficiency improvement by applying a generative AI model in an apparatus, a method, or a program therefor for creating technical documents necessary for software development.

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

Means for Solving the Problem

[0007] To achieve such an object, a first aspect of the present invention is a method for creating a technical document of software, including: a step of obtaining explanatory data in which an explanation of the software is expressed, the explanatory data including at least one of one or more sentences and one or more images; a step of 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 a step of making a second request to a second generative AI model to generate one or more business logics corresponding to the use case for at least any one of the one or more use cases.

[0008] Further, 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 in which a series of screens are represented.

[0009] Further, a third 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 sequence diagram showing the behavior of the software.

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

[0011] Further, a fifth aspect of the present invention is the method according to any one of the first to fourth aspects, further including a step of making a third request to a third generation AI model to generate API documents corresponding to at least one of the one or more business logics.

[0012] Further, a sixth aspect of the present invention is the method according to the fifth aspect, wherein the third request includes a template of an API document having items of a request type, parameters, endpoints, API response codes, and response bodies.

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

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

[0015] Further, a ninth aspect of the present invention is the method according to the sixth aspect, wherein the third request includes an instruction to generate at least one of the parameters, the endpoints, and the response bodies using column names included in the database design of the software.

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

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

[0018] Further, a twelfth aspect of the present invention is the method of the eleventh aspect, further including a step of making a fifth request to a fifth generative AI model to request to correct a use case in which the business logic can be used in accordance with the correction.

[0019] Further, a thirteenth aspect of the present invention is the method of the eleventh or twelfth aspect, further including a step of making a sixth request to a sixth generative AI model to request to correct API documentation corresponding to the business logic in accordance with the correction.

[0020] Further, a fourteenth aspect of the present invention is a method for creating software technical documentation, including a step of obtaining one or more use cases occurring in the software, a step of creating an instruction to generate one or more business logics corresponding to the one or more use cases for at least any one of the one or more use cases, and a step of executing a request k including the instruction to a generative AI model (k).

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

[0022] Further, a sixteenth aspect of the present invention is a program for causing a computer to execute a method for creating software technical documentation, the method including a step of obtaining one or more use cases occurring in the software, a step of creating an instruction to generate one or more business logics corresponding to the one or more use cases for at least any one of the one or more use cases, and a step of executing a request k including the instruction to a generative AI model (k).

[0023] Further, a 17th aspect of the present invention is an apparatus for creating technical documentation of software, which acquires one or more use cases occurring in the software, creates an instruction to generate one or more business logics corresponding to at least any one of the one or more use cases, and is configured to execute a request k including the instruction on a generation AI model (k).

[0024] Further, an 18th aspect of the present invention is a method for creating technical documentation of software, including the steps of acquiring one or more use cases occurring in the software, creating an instruction to generate one or more API documents corresponding to at least any one of the one or more use cases, and executing a request k including the instruction on a generation AI model (k).

[0025] Further, a 19th aspect of the present invention is the method of the 18th aspect, further including the step of storing the generated one or more API documents in association with the use case.

[0026] Further, a 20th aspect of the present invention is the method of the 18th aspect, further including the step of, before the request k, making a request l to a generation AI model (l) to generate a description of database design using the one or more use cases.

[0027] Further, a 21st aspect of the present invention is the method of the 18th aspect, further including the steps of acquiring a specification of an external API used in the software, and modifying at least any one of the one or more API documents generated by the request k based on one or more API documents of the external API.

[0028] Further, a 22nd aspect of the present invention is a program for causing a computer to execute a method for creating a technical document of software, the method including: obtaining one or more use cases occurring in the software; creating an instruction 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 instruction against a generation AI model (k).

[0029] Further, a 23rd aspect of the present invention is an apparatus for creating a technical document of software, configured to obtain one or more use cases occurring in the software, create an instruction 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 instruction against a generation AI model (k).

[0030] Further, a 24th aspect of the present invention is a method for creating a technical document of software, the method including: obtaining one or more use cases occurring in the software; performing, against a generation AI model (k), a request k for requesting to generate at least one of one or more business logics and one or more API documents available for at least one of the one or more use cases; and performing, against a generation AI model (l), a request l for requesting to generate code corresponding to at least one of the generated one or more business logics and one or more API documents.

[0031] Further, a 25th aspect of the present invention is the method according to the 24th aspect, further including performing a request m for requesting a code management system to reflect a branch in which the generated code is committed.

[0032] Further, a 26th aspect of the present invention is the method according to the 25th aspect, wherein the request m is a push of the code to the code management system.

[0033] Further, a 27th aspect of the present invention is the method according to the 25th or 26th aspect, further including a step of creating a branch name of the branch based on the use case before performing the requirement m.

[0034] Further, a 28th aspect of the present invention is the method according to the 27th aspect, further including a step of verifying that the created branch name does not overlap with an already created branch name.

[0035] Further, 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: a step of obtaining one or more use cases occurring in the software; and for at least any one of the one or more use cases, performing, on a generation AI model (k), a requirement k for requiring generation of at least one of one or more business logics and one or more API documents available for the use case; and performing, on a generation AI model (l), a requirement l for requiring generation of code corresponding to at least one of the generated one or more business logics and one or more API documents.

[0036] Further, a 30th aspect of the present invention is an apparatus for creating technical documentation of software, configured to obtain one or more use cases occurring in the software, and perform, on a generation AI model (k), a requirement k for requiring generation of at least one of one or more business logics and one or more API documents available for at least any one of the one or more use cases, and perform, on a generation AI model (l), a requirement l for requiring generation of code corresponding to at least one of the generated one or more business logics and one or more API documents.

Advantages of the Invention

[0037] According to one aspect of the present invention, based on at least any one of the acquired one or more use cases, one or more business logics available for the use case are generated, and if necessary, the process of further generating API documents corresponding to at least any one of the business logics is automated by applying one or more generation AI models, thereby significantly improving the efficiency of creating technical documents required for software development.

Brief Description of Drawings

[0038]

Figure 1

Figure 2

Figure 3A

Figure 3B

Figure 3C

Figure 3D

Figure 3E

Figure 3F

Figure 4

Figure 5

Figure 6

Figure 7

Figure 8

Figure 9

Figure 10A

Figure 10B

Figure 10C

Figure 11

Figure 12

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

[0040] (First Embodiment) FIG. 1 shows an apparatus according to a first embodiment of the present invention. The apparatus 100 communicates via an IP network such as the Internet with a user terminal 110 used by a user and a platform 120 that provides a generation AI model in order to create technical documents necessary for software development. Although the generation AI model will be exemplarily described as being provided by a platform 120 capable of communicating with the apparatus 100, it is also possible to execute an application for providing the generation AI model on the apparatus 100 so that the apparatus 100 provides the generation AI model.

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

[0042] First, the device 100 receives description data in which descriptions of the software to be developed are expressed (S201). The description data includes at least one of one or more sentences and one or more images. The one or more sentences can include one or more sentences that describe the purpose of use, operation procedures, etc. of the software. Here, the description data is described as being received by the device 100, but as long as the device 100 can obtain the description data as a result. As an example, the device 100 may receive a video about the software to be developed and analyze it to obtain the description data. Also, an input may be received through a text-form or voice-form chat with an AI model, and the description data may be obtained by processing this as necessary.

[0043] Next, the device 100 generates natural language descriptions of a plurality of use cases that occur in the software based on the description data. Hereinafter, the case where the device 100 receives a plurality of images in which a series of screens as shown in FIGS. 3A to 3F are expressed as the description data will be mainly described as an example. In this case, the device 100 can generate a use case with each screen as a UI. Examples of the images included in the description data include, in addition to such GUIs, sequence diagrams showing the behavior of the software. Also, the description data may include one or more texts associated with one or more UI components included in the images included in the description data. When an API call occurs in response to a UI component being selected, the text associated with the UI component may include the endpoint of the API. Also, when the UI component is an icon, the text associated with the icon may include the position of the icon.

[0044] Use case generation, more specifically, as an example, the apparatus 100 requests (also referred to as the "first request") a generation AI model (also referred to as the "first generation AI model") to generate a plurality of use cases based on the description data (S202), the first generation AI model generates a plurality of use cases (S203), and can be performed by transmitting the generated plurality of use cases to the apparatus 100 (S204). FIG. 2 shows an example in which a plurality of use cases are generated, but depending on the content of the description data, there may be cases where one use case is generated. Also, when the description data itself describes one or more use cases in natural language, the use case generation process may not be performed. Also, when the description data itself describes one or more use cases in natural language, the use case may be regenerated based on the description data.

[0045] Before making the first request, the apparatus 100 may determine one or more data formats of the acquired description data and include in the first request an instruction according to the determination result for the first generation AI model. The instruction is also called a prompt, and the first generation AI model generates an output using this as an input. Specifically, depending on whether the description data is in text format, image format, or includes both, different prompts may be included in the first request.

[0046] FIG. 4 shows 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 sending use case viewing screen display information, or more briefly, use case display information, from the device 100 to the user terminal 110 as, for example, a file in HTML format, and viewing it on the use case viewing screen 400 displayed on the display screen of the user terminal 110 via a web browser, or by operating an application installed on the user terminal 110 and viewing it from the use case viewing screen 400 displayed within the application using the received use case display information. Also, the generated use case may be output to the command prompt on the user terminal 110. Note that the “viewing screen” can adopt various forms such as a web page, a modal window, a pop-up window, etc. when displayed on a web browser, and can be a single screen of the application when displayed within the application. In any case, as long as it is a screen including an area for viewably displaying the generated use case, it corresponds to the viewing screen. The same technology can be applied to other screens mentioned in this specification. Although not shown here, the use case viewing screen 400 can be made editable for the use case.

[0047] The use case shown on screen 400 in FIG. 4 is a natural language description of the behavior of the attendance management system that provides the UIs shown in FIGS. 3A to 3F at the time of check-in, and corresponds to the UI shown in FIG. 3C. The use case includes, as items, an actor and a flow, and may further include at least one of a precondition and a postcondition. The use case 400 shown in FIG. 4 has an actor who is an employee, and it is stipulated that as a precondition, the employee needs to be logged in to the attendance management system, and as a postcondition, the employee's attendance is recorded on the current date. And the use case 400 describes a flow, that is, a series of behaviors of the system. Specifically, when the employee clicks the "Check In" button, the system is described as performing verification of the employee's identity, recording of attendance, and display of a confirmation message, and displaying an error message if the verification fails. Also, in the use case 400, three alternative flows are described. Here, when the use case at the time of check-in is described, 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 plurality of generated use cases, the apparatus 100 generates one or more business logics available for the use case. Here, "business logic" refers to the logic for processing data transmitted or received in communication with the UI based on business requirements. Here, "logic" means a series of instructions.

[0049] Business logic generation, more specifically, as an example, the apparatus 100 requests (also referred to as the "second request") the generation AI model (also referred to as the "second generation AI model") to generate one or more business logics available for the use case based on the use case (S205), the second generation AI model generates one or more business logics (S206), and can be performed by transmitting the generated one or more business logics to the apparatus 100 (S207). Although the above process has been described for each of the plurality of generated use cases, as in the example shown in FIG. 2, there may be a case where one or more business logics are generated for at least any one of the plurality of generated use cases.

[0050] FIG. 5 shows an example of business logic generated by the second generation AI model according to the first embodiment of the present invention. The browsing of the generated business logic can be performed on the business logic browsing screen 500 displayed on the display screen of the user terminal 110 by transmitting the business logic browsing screen display information, more briefly the business logic display information, from the apparatus 100 to the user terminal 110 in the same manner as the use case. Although the business logic browsing screen 500 is not shown here, the business logic can be made editable.

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

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

[0053] The example of FIG. 6 is an example of a prompt described in natural language that is included as part of the code written in the programming language TypeScript. By executing the code, the OpenAI API can be called to generate one or more business logics available for the use case set in the second generation 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 may be stored in the storage unit 103, and the device 100 may acquire it and execute the code including the instruction obtained by setting the required values in the variables included in the code. Although a specific example of the first request for the first generation AI model is not shown, those skilled in the art should be able to fully understand the implementation of the first request based on the description of the second request for the second generation AI model.

[0054] In FIG. 2, the first generation AI model and the second generation AI model are distinguished, but they may also be the same generation AI model. As the generation AI model, an LLM to which a transformer architecture is particularly applied is preferable, but it is assumed that the name of the architecture will change due to technological advancements. Therefore, in this specification, the "transformer architecture" includes an architecture using one or more features of the transformer architecture or an improvement thereof. Whether the "generation AI model" is the same in this specification is determined by whether the types of generation AI models specified by the user are the same. For example, in the case of the OpenAI API, if the value of the variable "model" is the same, it is expressed as being the same as the generation AI model. If the first generation AI model and the second generation AI model are not the same, they may be provided on the same platform 120. In the example of FIG. 2, where a second request is made after the first request, if the first generation AI model and the second generation AI model are the same generation AI model or generation AI models provided on the same platform, these requests may be made by a single call to the API. Also, needless to say, the first and second requests may each include a plurality of requests and may include one or more processes performed by the device 100 other than the requests for the generation AI model.

[0055] If the set use case is long and the length of the instruction for the second generative AI model included in the second request exceeds the upper limit defined for the second generative AI model, a request may be made to a generative AI model provided on platform 120 or another platform to generate a summary of the use case, and the obtained summary may be set in the variable {use_case} to make the second request. In this way, the data set in the variable {use_case} may also be data corresponding to the use case. For example, any one of the one or more data generated based on the use case may be set as a variable so that the generation of one or more business logics is performed in a smaller unit instead of 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 generated one or more business logics, the apparatus 100 generates API documents corresponding to each business logic as necessary. Here, the "API document" refers to a document that describes the functions and usage methods of the API.

[0057] More specifically, as an example, API document generation can be performed by the apparatus 100 requesting (also referred to as the "third request") a generative AI model (also referred to as the "third generative AI model") to generate API documents corresponding to each of the generated one or more business logics (S208), the third generative AI model generating the API documents (S209), and transmitting the generated API documents to the apparatus 100 (S210). Although the case where the above processing is performed for each of the generated one or more business logics has been described as in the example shown in FIG. 2, there may be cases where one or more API documents are generated for at least any one of the generated multiple business logics. Also, there may be cases where one or more API documents corresponding to all or part of the generated one or more business logics are generated.

[0058] FIG. 8 shows an example of an API document according to the first embodiment of the present invention. The API document displayed on the screen 800 in FIG. 8 includes, as items, a request type, a parameter, an endpoint, an API response code, and a response body, and may further include at least any 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, so that it is possible to grasp for which implementation of any business logic the API described in the API document can be used. One API may be available for multiple business logics.

[0059] The browsing of the API document can be performed, for example, on an API document browsing screen 800 displayed on the display screen of the user terminal 110 by transmitting API document browsing screen display information, or more briefly, API document display information, from the device 100 to the user terminal 110 in the same way as the use case. At this time, the response body is preferably described in the API document display information so as to be displayable in JSON format. Although not shown here, the API document browsing screen 800 can be made editable.

[0060] Figure 9 shows an example of a prompt described in natural language that is included as part of a third request for a third generation AI model according to the first embodiment of the present invention. In this prompt, as context, the variable {business_logics} can be set with one or more business logics corresponding to one or more API documents to be generated. Alternatively, any one of one or more data generated based on the business logic can be set as a variable, and the generation of one or more API documents can be performed in units smaller than the business logic unit. Also, in this prompt, as context, the variable {response_example} can be set with a template of the API document to be generated. The items that such a template may include are as described above. In the example of Figure 9, in addition to the business logic, values are set as context variables for the use cases in which the business logic can be used. However, if the business logic is given, it is possible to cause the third generation AI model to generate the corresponding API document. In this prompt, as context, the variable {database_design} can be further set with a database design, which will be described in the second embodiment.

[0061] The example in FIG. 9 is part of the code written in the programming language TypeScript. By executing this code, the OpenAI API can be called to generate one or more API documents corresponding to the business logic set in the third generation AI model provided on 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 third request may be stored in the storage unit 103, and the device 100 may acquire this code and execute the code including instructions obtained by setting the required values in the variables included in the code. In this example, one or more API documents corresponding to the set business logic are generated. However, either the use case or one or more of the data generated based on the use case may be set as variables so that the corresponding one or more API documents are generated.

[0062] In FIG. 2, the case where the third generation AI model is the same as the second generation AI model is shown, but these may be different generation AI models. When the second generation AI model and the third generation AI model are not the same, they may be provided on the same platform 120. In the example of FIG. 2, the third request is made after the second request. When the second generation AI model and the third generation AI model are the same generation AI model or generation AI models provided on the same platform, these requests may be made by a single call to the API. Also, 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 generation AI model.

[0063] Device 100 may receive or obtain a specification of an external API to be used in software. The specification can be, for example, the name of the external API or one or more URLs of one or more API documents of the external API. When the external API is specified, Device 100 may obtain one or more API documents of the external API and store them in association with the software. For example, based on one or more API documents of the external API stored in this way, at least one of the one or more API documents generated by a third request can be modified, replaced, or otherwise changed to enable the external API to be called normally.

[0064] Device 100 may receive the generated one or more use cases and the technical documents generated using them, and transmit them to user terminal 110 (S211). Here, as a specific example, the generated one or more business logics and one or more API documents corresponding to them are included in the technical documents.

[0065] As described above, based on at least one of the obtained one or more use cases, one or more business logics available for the use case are generated, and if necessary, the process of further generating API documents corresponding to at least some of the business logics is automated by applying one or more generation AI models, thereby greatly improving the efficiency of creating technical documents required for software development.

[0066] Before proceeding to generate business logic using the use case, the use case may be verified. The verification can be, for example, to verify that the use case satisfies the conditions necessary for generating business logic using it. Also, before proceeding to create an API document using the business logic, the business logic may be similarly verified.

[0067] (Second Embodiment) As in the examples of the prompts in FIGS. 6 and 9 described in the first embodiment, as the context, a description of the database design may be set in the variable {database_design}. In this case, as in the example of FIG. 6, an instruction to determine the input items included in the business logic using the column names included in the database design can be included in the second request. By doing so, business logic that is consistent with the database design can be obtained. Also, an instruction to determine terms included in at least any one of the actor, flow, preconditions, and postconditions included in the use case using the column names included in the database design can be included in the first request, or as in the example of FIG. 9, at least any one of the parameters, endpoints, validations, request bodies, and response bodies included in the API document can be included in the third request. An instruction to determine using the column names included in the database design.

[0068] The description of the database design may be obtained by the apparatus 100 receiving it from the user terminal 110, or may be generated by a generative AI model based on one or more use cases generated or obtained by the apparatus 100. More specifically, the apparatus 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 with the generation of the database design based on one or more use cases, the one or more use cases may be verified. The verification can be, for example, a verification that the one or more use cases satisfy the conditions necessary for generating the database design based on them. Also, the fourth request may include a plurality of requests and may include one or more processes performed by the apparatus 100 other than the request for the fourth generative AI model.

[0069] Similar to the second and third claims, the fourth claim is also possible by preparing the code in advance and having the apparatus 100 execute the code containing instructions obtained by setting the necessary variables thereto. The fourth generative AI model may be the same as at least any one of the first to third generative AI models or may be provided on the same platform or apparatus. Of course, if the variable {database_design} is set in the second and third claims, it is necessary to execute the fourth claim before the second and third claims.

[0070] FIG. 11 shows an example of a prompt described in natural language that is partially included in the code for the fourth claim that requests generation of a description of the database design of the attendance management system according to the second embodiment of the present invention. In the prompt, as context, one or more use cases are set in the variable {use_case}, and one or more tables created so far are set in the variable {previous_tables}. Also, in the prompt, data for specifying one or more APIs from which API documents are generated from one or more use cases set in the variable {use_case} is set in the variable {apis}, enhancing the accuracy when creating at least any one of new tables, columns, and relations. In the variable {use_case}, data corresponding to the use case rather than the use case itself may be set. For example, by analyzing the use case, one or more tables required in the use case and the relations between the tables may be extracted and set in the variable. Here, an example of an ERD is shown, but it is not necessarily limited to an ERD.

[0071] (Third Embodiment) The technical document sent to the user terminal 110 can be displayed in an editable format on the display screen of the user terminal 110, and the user of the user terminal 110 can make modifications (S212). Then, the added modifications are sent from the user terminal 110 to the apparatus 100, and the apparatus 100 can request (also referred to as the "fifth request") the generative AI model (also referred to as the "fifth generative AI model") to modify at least any one of the use cases according to the modification. More specifically, when the user makes a modification to a certain business logic, the fifth request can be a request to modify the use cases that utilize the business logic (S213).

[0072] Generally, since use cases are created by members on the business side and technical documents are created by members on the development side, it is not easy to maintain the consistency between use cases and the technical documents based on them. By performing the modification of the use cases according to this embodiment, it becomes realistically possible to maintain the consistency between the two.

[0073] When a modification to the business logic is added, in addition to or instead of modifying the use cases, it is possible to further request (also referred to as the "sixth request") the generative AI model (also referred to as the "sixth generative AI model") to modify the API document corresponding to the business logic.

[0074] Similar to the second request and the third request, the fifth request and the sixth request can be made possible by preparing the code in advance and having the apparatus 100 set the necessary variables and execute it. The fifth generative AI model and the sixth generative AI model may be the same as at least any one of the first to third generative AI models or provided on the same platform or apparatus. Also, the fifth and sixth requests may each include a plurality of requests and may include one or more processes performed by the apparatus 100 other than the requests to the generative AI model.

[0075] (Fourth Embodiment) For all or part of the acquired one or more use cases, at least one of the one or more business logics and the one or more API documents available for the use case can be generated by a generation AI model, and the code corresponding to the generated technical document can be further generated by the generation AI model. FIG. 12 shows this process (S1201 to S1207).

[0076] In FIG. 12, the generation of use cases, the generation of technical documents, and the generation of code are shown as being performed by requests for a first generation AI model, a second generation AI model, and a third generation AI model, respectively. However, these generation AI models may be the same generation AI model, different generation AI models provided on the same platform 120, or different generation AI models provided on different platforms. Also, the generation of technical documents may be performed by separately generating business logic and API documents as in the foregoing embodiments. When the plurality of generation AI models are the same generation AI model or generation AI models provided on the same platform, requests for these generation AI models may be made by a single call to the API. Also, the requests for each generation AI model may include a plurality of requests and may include one or more processes performed by the apparatus 100 other than the requests for the generation AI model. The requests for each generation AI model can be made by preparing code in advance and causing the apparatus 100 to execute code including an instruction to create the code by setting necessary variables therein.

[0077] The device 100 that has obtained the generated code can create a branch to which the code is committed using a branch name corresponding to the use case to which the code corresponds (S1208). Then, the device 100 may, if necessary, verify that the created branch name does not overlap with the already created branch names. Thereby, branches can be reliably separated for each use case. In FIG. 12, it is shown that the device 100 creates the branch name, but it may be configured to request an external device from the device 100 to create it. 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 then commits the generated code (S1209). In FIG. 12, it is shown that the generated code is committed at once, but it may be committed multiple times by dividing it into organized parts. The commit message that can be specified for each commit can also be generated by a request from the device 100 to the generation AI model according to the changes to be committed. Also, regarding the above-mentioned branch name, it can also be generated by a request from the device 100 to the generation AI model according to the use case.

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

[0080] In this way, by creating a branch locally using a branch name corresponding to the use case and pushing it to the remote repository, the code required for the software to be developed can be managed on a per-use case basis.

[0081] In the description up to this point regarding this embodiment, the use case unit has been assumed. However, as described in the first embodiment, based on the use case, a plurality of data are generated in predetermined units such as tickets and tasks, and in these data units, the generation of technical documents and the generation of their corresponding code are performed, and the branches to which the generated code is committed may be managed by the code management system 130. In this case, the branch name will be created and specified according to each of the plurality of data generated based on the use case.

[0082] In addition, the apparatus 100 requests the code management system 130 for a pull request regarding the pushed branch (S1211), and the code management system 130 can execute the pull request (S1212).

[0083] Note that in the above-described embodiments, if there is no description of "only" such as "based only on", "responding only to", "only in the case of", "referring only to", it is assumed that additional information can be considered in this specification. Also, as an example, note that the description "do b in the case of a" does not necessarily mean "always do b in the case of a" or "do b immediately after a" except when explicitly stated. Also, the description "each a that constitutes A" does not necessarily mean that A is constituted by a plurality of components, and includes the case where the component is singular.

[0084] Also, as a precaution, even if there is an aspect of performing operations different from the operations described in this specification in some method, program, terminal, device, server, or system (hereinafter referred to as "method, etc."), each aspect of the present invention is directed to the same operations as any of the operations described in this specification, and it is noted that the existence of operations different from the operations described in this specification does not exclude the method, etc. from the scope of each aspect of the present invention.

[0085] Also, it should be noted that the disclosure of this specification includes arbitrarily combining the above-described embodiments of the present invention within a range that does not conflict with each other.

[0086] Also, in the above description, when referring to a plurality of generation AI models, for example, in the second embodiment, it may be necessary to request the fourth AI model before requesting the second generation AI model and the third generation AI model. In such a case, from the perspective 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)". For other cases, similarly, appropriate substitutions may be made as needed.

Description of Reference Numerals

[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 Browsing Screen 500 Business Logic Browsing Screen 800 API Document Browsing Screen

Claims

1. 1. A method for creating technical documentation for software, comprising the steps of: obtaining description data representing a description of the software, the description 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 description data; 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; Includes.

2. 2. The method of claim 1 , the descriptive data includes one or more images; The one or more images include a plurality of images in which a sequence of scenes is depicted.

3. 2. The method of claim 1 , the descriptive data includes one or more images; The one or more images include a sequence diagram illustrating the behavior of the software.

4. 4. A method according to any one of claims 1 to 3, comprising: The second request includes a business logic template having items of input, logic, and response.

5. 5. A method according to any one of claims 1 to 4, comprising: The method further includes 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.

6. 6. The method of claim 5, The third request includes a template API document having fields for a request type, a parameter, an endpoint, an API response code, and a response body.

7. 7. The method of claim 6, The API document template further includes a corresponding business logic section.

8. 5. The method of claim 4, further comprising: The second request includes instructions to generate the input items using column names included in the software's database design.

9. 7. The method of claim 6, further comprising: The third request includes an instruction to generate at least one of the parameters, the endpoint, and the response body using column names included in a database design of the software.

10. 10. The method according to claim 8 or 9, The method further includes making a fourth request prior to the second request and the third request, requesting a fourth generative AI model to generate a description of a database design using the one or more use cases.

11. 11. A method according to any one of claims 1 to 10, comprising: transmitting at least one of the generated one or more business logics to the user terminal; receiving modifications to the business logic from the user terminal; Further includes:

12. 12. The method of claim 11, The method further includes making a fifth request to a fifth generative AI model to modify use cases that can utilize the business logic according to the modifications.

13. 13. The method according to claim 11 or 12, The method further includes making a sixth request to a sixth generative AI model to modify an API document corresponding to the business logic according to the modification.

14. 1. A method for creating technical documentation for software, comprising the steps of: obtaining one or more use cases occurring in the software; For at least one of the one or more use cases, creating instructions for generating one or more business logics corresponding to the use case; executing a request k including the instruction on a generative AI model (k); Includes.

15. 15. The method of claim 14, The method further includes storing the generated one or more business logics in association with the use case.

16. A program for causing a computer to execute a method for creating technical documentation for software, the method comprising: obtaining one or more use cases occurring in the software; For at least one of the one or more use cases, creating instructions for generating one or more business logics corresponding to the use case; executing a request k including the instruction on a generative AI model (k); Includes.

17. An apparatus for creating technical documentation for software, comprising: Acquire one or more use cases occurring in the software, and for at least one of the one or more use cases, The system is configured to create instructions for generating one or more business logics corresponding to the use case, and execute a request k including the instructions to a generative AI model (k).

18. 1. A method for creating technical documentation for software, comprising the steps of: obtaining one or more use cases occurring in the software; For at least one of the one or more use cases, generating instructions for generating one or more API documents corresponding to the use case; executing a request k including the instruction on a generative AI model (k); Includes.

19. 20. The method of claim 18, The method further includes storing the generated one or more API documents in association with the use case.

20. 20. The method of claim 18, The method further includes, prior to 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.

21. 20. The method of claim 18, obtaining a specification of an external API to be used by the software; 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; Further includes:

22. A program for causing a computer to execute a method for creating technical documentation for software, the method comprising: obtaining one or more use cases occurring in the software; creating, for at least one of the one or more use cases, an instruction to generate one or more API documents corresponding to the use case; executing a request k including the instruction on a generative AI model (k); Includes.

23. An apparatus for creating technical documentation for software, comprising: The system is configured to obtain one or more use cases occurring in the software, create instructions for generating one or more API documents corresponding to at least any of the one or more use cases, and execute a request k including the instructions to a generative AI model (k).

24. 1. A method for creating technical documentation for software, comprising the steps of: obtaining one or more use cases occurring in the software; making a request k to a generative AI model (k) for generating at least one of one or more business logics and one or more API documents usable for at least one of the one or more use cases; making a request l to the generative AI model (l) to generate code corresponding to at least one of the generated business logic(s) and API documentation(s); Includes.

25. 25. The method of claim 24, The method further includes a step of making a request m to the code management system to reflect the generated code in the committed branch.

26. 26. The method of claim 25, The request m is a push of the code to the code management system.

27. 27. The method of claim 25 or 26, comprising: The method further includes creating a branch name for the branch based on the use case before making the request m.

28. 28. The method of claim 27, The method further includes the step of verifying that the created branch name does not overlap with any branch names already created.

29. A program for causing a computer to execute a method for creating technical documentation for software, the method comprising: obtaining one or more use cases occurring in the software; making a request k to a generative AI model (k) for generating at least one of one or more business logics and one or more API documents usable for at least one of the one or more use cases; making a request l to the generative AI model (l) to generate code corresponding to at least one of the generated business logic(s) and API documentation(s); Includes.

30. An apparatus for creating technical documentation for software, comprising: Obtaining one or more use cases that occur in the software; For at least one of the one or more use cases, a request k is made to the generative AI model (k) to 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 configured to make a request l to the generative AI model (l) requesting generation of code corresponding to at least one of the generated one or more business logics and one or more API documents.

Images