Apparatus, method and program for generating technical documentation for software

Abstract

A method for generating technical documentation corresponding to source code is provided. In response to a repository selection received from a user terminal 110, the device 100 receives repository information related to the repository from a code management system 130 (S201 to S203). The device 100 then extracts multiple API code candidates and one or more root file candidates from the repository information (S204). The device 100 then requests a generative AI model (k) to determine paths for the multiple API codes and one or more root files using the extracted file candidates (S205) and receives the determined paths (S206). For each API code, the device 100 requests a generative AI model (l) to generate API documentation corresponding to the API code, and receives and stores the generated technical documentation (S207 to S209).

Description

[Technical Field]

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

[0002] There are various methods for developing software. One method involves first creating use cases, then creating technical documentation that describes more technical details, and then performing the necessary coding based on the documentation to create source code.

[0003] In recent years, there has been progress in the development of technology for automatically generating source code based on technical documents. For example, the applicant has disclosed a technology for obtaining table definitions and API definitions for multiple tables and APIs required by software, and generating source code in accordance with the table definitions and API definitions (see Patent Document 1). [Prior art documents] [Patent documents]

[0004] [Patent Document 1] Japanese Patent Publication No. 2023-031251 Summary of the Invention [Problem to be solved by the invention]

[0005] Users of services that use such automatic source code generation technology typically manage the generated source code in a code management system such as GitHub (registered trademark). If changes or additions to functionality become necessary as software is provided using the source code, the source code is modified. When such modifications occur, the technical documentation stored in the source code generation service no longer corresponds to the source code. Therefore, even if users wish to further expand functionality using the service, the generated source code will be inconsistent with modifications made outside the service.

[0006] Furthermore, for users who want to modify or add functions to existing software using a source code generation service, the service is unable to do so because the technical documentation corresponding to the software is not maintained by the service.

[0007] The present invention has been made in view of the above points, and an object of the present invention is to provide an apparatus, a method, or a program for generating technical documentation corresponding to source code. [Means for solving the problem]

[0008] In order to achieve this object, a first aspect of the present invention is a method for generating technical documentation corresponding to source code managed in a code management system, comprising the steps of receiving repository information regarding a repository in which the source code is managed; determining, from the repository information, paths of multiple API codes and one or more root files; and making a first request to a first AI model, which is a generative AI model, to generate API documentation corresponding to at least one of the multiple API codes, wherein the first request includes code in the one or more root files; and storing the generated one or more API documents.

[0009] Also, a second aspect of the present invention is a method of the first aspect, wherein the determining step includes a step of making a second request to a second AI model, which is a generative AI model, to determine paths of the plurality of API codes and the one or more root files from the repository information.

[0010] Furthermore, a third aspect of the present invention is the method of the second aspect, wherein the determining step further includes a step of extracting a plurality of API code candidates and one or more root file candidates from the repository information before making the second request.

[0011] A fourth aspect of the present invention is the method according to the first aspect, wherein the determination is made using a directory structure of the repository.

[0012] Furthermore, a fifth aspect of the present invention is a method of any one of the first to fourth aspects, further comprising a step of transmitting API document viewing information to a user terminal for viewing at least one of the one or more API documents.

[0013] In addition, a sixth aspect of the present invention is a method for generating technical documentation corresponding to source code, comprising the steps of receiving source code information regarding the source code, determining paths of a plurality of API codes and one or more root files from the source code information, and making a first request to a first AI model, which is a generative AI model, to generate API documentation corresponding to at least one of the plurality of API codes, wherein the first request includes code in the one or more root files, and storing the generated one or more API documentation.

[0014] Furthermore, a seventh aspect of the present invention is a method for generating technical documentation corresponding to source code managed in a code management system, comprising the steps of receiving repository information regarding a repository in which the source code is managed; determining paths of multiple business logic codes from the repository information; making a first request to a first AI model, which is a generative AI model, to generate business logic corresponding to at least one of the multiple business logic codes; and storing multiple business logic codes corresponding to the multiple business logic codes.

[0015] In addition, an eighth aspect of the present invention is a method for generating technical documentation corresponding to source code, comprising the steps of receiving source code information regarding the source code, determining paths of multiple business logic codes from the source code information, making a first request to a first AI model, which is a generative AI model, to generate business logic corresponding to at least one of the multiple business logic codes, and storing the generated business logic or business logics.

[0016] In addition, a ninth aspect of the present invention is a program for causing a computer to execute a method for generating technical documentation corresponding to source code managed in a code management system, the method including the steps of receiving repository information regarding a repository in which the source code is managed; determining the paths of multiple API codes and one or more root files from the repository information; and making a first request to a first AI model, which is a generative AI model, to generate API documentation corresponding to at least one of the multiple API codes, wherein the first request includes code in the one or more root files; and storing the generated one or more API documents.

[0017] In addition, a tenth aspect of the present invention is a program for causing a computer to execute a method for generating technical documentation corresponding to source code, the method including the steps of receiving source code information regarding the source code, determining paths of multiple API codes and one or more root files from the repository information, and making a first request to a first AI model, which is a generative AI model, to generate API documentation corresponding to at least one of the multiple API codes, wherein the first request includes code in the one or more root files, and storing the generated one or more API documentation.

[0018] In addition, an eleventh aspect of the present invention is an apparatus for generating technical documentation corresponding to source code managed in a code management system, configured to receive repository information regarding a repository in which the source code is managed, determine paths of multiple API codes and one or more root files from the repository information, make a first request to a first AI model, which is a generative AI model, to generate API documentation corresponding to at least one of the multiple API codes, the first request including code in the one or more root files, and store the generated one or more API documents.

[0019] In addition, a twelfth aspect of the present invention is an apparatus for generating technical documentation corresponding to source code, configured to receive source code information regarding the source code, determine paths of multiple API codes and one or more root files from the source code information, make a first request to a first AI model, which is a generative AI model, to generate API documentation corresponding to at least one of the multiple API codes, the first request including code in the one or more root files, and store the generated one or more API documentation.

[0020] In addition, a 13th aspect of the present invention is a program for causing a computer to execute a method for generating technical documentation corresponding to source code managed in a code management system, the method including the steps of receiving repository information regarding a repository in which the source code is managed; determining paths of multiple business logic codes from the repository information; making a first request to a first AI model, which is a generative AI model, to generate business logic corresponding to at least one of the multiple business logic codes; and storing multiple business logics corresponding to the generated one or more business logic codes.

[0021] In addition, a 14th aspect of the present invention is a program for causing a computer to execute a method for generating technical documentation corresponding to source code, the method including the steps of receiving source code information regarding the source code, determining paths of multiple business logic codes from the source code information, making a first request to a first AI model, which is a generative AI model, to generate business logic corresponding to at least one of the multiple business logic codes, and storing the generated business logic or business logics.

[0022] In addition, a 15th aspect of the present invention is an apparatus for generating technical documentation corresponding to source code managed in a code management system, configured to receive repository information regarding a repository in which the source code is managed, determine paths of multiple business logic codes from the repository information, make a first request to a first AI model, which is a generative AI model, to generate business logic corresponding to at least one of the multiple business logic codes, and store the generated business logic or business logics.

[0023] In addition, a 16th aspect of the present invention is an apparatus for generating technical documentation corresponding to source code, configured to receive source code information regarding the source code, determine paths of multiple business logic codes from the source code information, make a first request to a first AI model, which is a generative AI model, to generate business logic corresponding to at least one of the multiple business logic codes, and store the generated multiple business logics.

[0024] In addition, a 17th aspect of the present invention is a method for generating technical documentation corresponding to source code managed in a code management system, comprising the steps of receiving repository information regarding a repository in which the source code is managed; obtaining input regarding technical documentation; determining, from the repository information, paths of one or more pieces of code related to the input; making a first request to a first AI model, which is a generative AI model, to generate technical documentation corresponding to at least a portion of the one or more pieces of code; and storing the generated one or more technical documentation.

[0025] An eighteenth aspect of the present invention is the method of the seventeenth aspect, wherein the input is a description by a user.

[0026] Furthermore, a 19th aspect of the present invention is the method of the 18th aspect, wherein the description is a message entered on a chat screen displayed on a user terminal used by the user.

[0027] A twentieth aspect of the present invention is the method of the seventeenth aspect, wherein the input is a selection of the type of technical document to be generated.

[0028] In addition, a 21st aspect of the present invention is a program for causing a computer to execute a method for generating technical documentation corresponding to source code managed in a code management system, the method including the steps of receiving repository information regarding a repository in which the source code is managed, obtaining input regarding technical documentation, determining from the repository information a path of one or more pieces of code related to the input, making a first request to a first AI model, which is a generative AI model, to generate technical documentation corresponding to at least a portion of the one or more pieces of code, and storing the generated one or more technical documentation.

[0029] In addition, a 22nd aspect of the present invention is an apparatus for generating technical documentation corresponding to source code managed in a code management system, configured to receive repository information regarding a repository in which the source code is managed, receive input regarding technical documentation, determine from the repository information a path of one or more pieces of code related to the input, make a first request to a first AI model, which is a generative AI model, to generate technical documentation corresponding to at least a portion of the one or more pieces of code, and store the generated one or more technical documentation.

[0030] In addition, a 23rd aspect of the present invention is a method for generating technical documentation corresponding to source code, comprising the steps of receiving source code information about the source code, obtaining input about technical documentation, determining from the source code information a path of one or more pieces of code related to the input, making a first request to a first AI model, which is a generative AI model, to generate technical documentation corresponding to at least a portion of the one or more pieces of code, and storing the generated one or more technical documentation.

[0031] A 24th aspect of the present invention is the method of the 23rd aspect, wherein the input is a description by a user.

[0032] A 25th aspect of the present invention is the method of the 24th aspect, wherein the description is a message entered on a chat screen displayed on a user terminal used by the user.

[0033] A 26th aspect of the present invention is the method of the 23rd aspect, wherein the input is a selection of the type of technical document to be generated.

[0034] Also, a 27th aspect of the present invention is a program for causing a computer to execute a method for generating technical documentation corresponding to source code, the method including the steps of receiving source code information about the source code, obtaining input about technical documentation, determining from the source code information a path of one or more pieces of code related to the input, making a first request to a first AI model, which is a generative AI model, to generate technical documentation corresponding to at least a portion of the one or more pieces of code, and storing the generated one or more technical documentation.

[0035] Furthermore, a 28th aspect of the present invention is an apparatus for generating technical documentation corresponding to source code, configured to receive source code information regarding the source code, receive input regarding technical documentation, determine from the source code information a path of one or more pieces of code related to the input, make a first request to a first AI model, which is a generative AI model, to generate technical documentation corresponding to at least some of the one or more pieces of code, and store the generated one or more technical documentation.

[0036] According to one aspect of the present invention, the paths of required types of files such as API code and business logic code are determined from repository information regarding the repository where source code is managed, and technical documentation corresponding to at least some of those files is automatically generated using a generative AI model, thereby bridging the gap between software development and documentation creation. [Brief explanation of the drawings]

[0037] [Figure 1] 1 illustrates a system for generating technical documentation according to one embodiment of the present invention. [Figure 2] 1 is a flow diagram illustrating a method for generating technical documentation according to an embodiment of the present invention; [Figure 3] FIG. 10 illustrates an example of a prompt included as part of the code for a request k requesting determination of a path for technical documentation according to one embodiment of the present invention. [Figure 4] FIG. 10 is a diagram showing an example of code for creating a prompt that is included as part of the code for a request l to a generative AI model (l) according to one embodiment of the present invention. [Figure 5] FIG. 5 is a diagram showing an example of a template “BUILD_API_FROM_CODE” used in FIG. 4. DETAILED DESCRIPTION OF THE INVENTION

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

[0039] FIG. 1 shows a system for generating technical documentation according to an embodiment of the present invention. To create technical documentation for software, the device 100 communicates with a user terminal 110 used by a user, a code management system 120, and a platform 130 that provides a generative AI model via an IP network such as the Internet. While the generative AI model is illustratively provided by the platform 130, which can communicate with the device 100, an application for providing the generative AI model may be executed on the device 100, causing the device 100 to provide the generative AI model. The device 100 may also provide a source code generation service to a user, which generates source code corresponding to the technical documentation. The device 100 may communicate with the user terminal 110 via a closed network, such as an intranet or local area network, accessible by the user terminal 110. In this case, security can be enhanced by providing the generative AI model on the device 100 or on a server 130 that can communicate with the device 100 via or within the closed network. In this case, security can also be enhanced by providing the code management system 120 on a system 120 that allows the device 100 and the user terminal 110 to communicate via or within the closed network, or by having the user terminal 110 itself function as the code management system 120.

[0040] 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.

[0041] First, the device 100 receives, from the user terminal 110, a selection of a repository on the code management system 120 that manages software for which technical documentation is to be created (S201). This selection can be made, for example, by displaying a selection screen for one or more repositories associated with a user who has logged in to a service provided by the device 100, and allowing the user to select one of the repositories.

[0042] Next, the device 100 requests repository information related to the repository from the code management system 120 (S202) and receives the repository information (S203). The repository information may include all files in the selected repository, or may exclude some files. Here, an example has been described in which the device 100 acquires repository information in response to a user's selection of a repository. However, the device 100 may detect changes, such as updates to files in a repository associated with the user, and acquire repository information related to the repository in response to the detection of the change. Furthermore, if the code management system 120 is provided on the user terminal 110, the repository information is transmitted from the user terminal 110 to the device 100. Alternatively, the user terminal 110 may manage source code without hosting a repository. In this case, all or some of the source code files may be transmitted from the user terminal 110 to the device 100. Even if the source code is managed in a remote repository or a local repository, the burden of configuring the device 100 for each hosting application is significant. Therefore, it is possible to create a command for transmitting all or some of the source code files directly to the device 100. In this way, when the source code is directly reflected in the device 100, the "repository information" referred to in this specification can be read as "source code information" relating to the source code acquired by the device 100.

[0043] After acquiring the repository information, the device 100 then extracts, as necessary, multiple API code candidates and one or more root file candidates from the repository information (S204). For example, this extraction can be performed by registering the paths or tree objects of multiple files contained in the acquired repository information in a vector database and identifying one or more files whose similarity to a specified term is equal to or exceeds a predetermined threshold. When generating API documentation, relevant terms include "API," "APIs," "Controller," "Controllers," "Route," and "Routes." When generating business logic, relevant terms include "Service," "Services," "Business Logic," "Business Logics," "Domain Logic," "Domain Logics," "Handler," and "Handlers." The larger the software development scale, the greater the number of files unrelated to the desired technical documentation. Therefore, extracting relevant file candidates and reducing the number of files to be processed subsequently can significantly increase the speed of generating technical documentation. Here, "API documentation" refers to a document describing the functions and usage of an API. The specified term or character string may be stored in the storage unit 103 according to the content of the technical document, or may be specified based on a description of the technical document to be created obtained from the user terminal 110. The description may be a message entered on a chat screen displayed on the user terminal 110. More generally, the input of the technical document to be created may be an input by the user obtained from the user terminal 110, and the input may be the above-mentioned description or a selection from a pull-down menu of technical document types such as API documentation, business logic, test cases, etc.

[0044] Then, the device 100 requests (also referred to as "request k") the AI ​​model (also referred to as "generative AI model (k)"), which is a generative AI model, to determine the paths of multiple API codes and one or more root files, using the extracted file candidates if file candidates have been extracted, or using the acquired repository information if not (S205). Here, a "root file" is a file in which one or more routes are described, and a "route" refers to the processing settings corresponding to a request, and more specifically, for an API-related route, refers to the processing settings corresponding to an API call. Only the paths of one or more root files related to the API may be determined, or the paths of one or more other root files may also be included.

[0045] FIG. 3 shows an example of an instruction called a prompt included as part of the code for request k to a generative AI model (k) according to one embodiment of the present invention. In this prompt, the variable {files} is set to the paths of all or multiple files included in the repository information. The prompt also describes specifying business logic code, API code, or root files, and outputting the paths of each specified file along with the category name in a predetermined format. If the purpose is to generate API documentation and business logic generation is not required, specifying business logic code is not necessarily required. Here, "business logic" refers to logic for processing data sent or received through communication with a user interface (UI) based on business requirements, and "logic" refers to a series of instructions. If the purpose is to generate test cases, it is sufficient to output one or more code paths necessary to provide the function targeted by the test case. Here, "testing" refers to verifying whether a specific software function operates correctly according to requirements, and examples include unit testing, integration testing, system testing, E2E testing, and acceptance testing. A "test case" refers to a document describing the procedure for such testing.

[0046] The example in FIG. 3 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 calls the OpenAI API and causes a generative AI model (k) provided on the platform 130 to determine a path. 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 request k is stored in the storage unit 103, and the device 100 acquires this code and executes code containing instructions obtained by setting required values ​​to variables included in the code, thereby making request k. When input related to a technical document to be created is acquired from the user terminal 110, the prompt can be modified to determine the path of one or more pieces of code related to or corresponding to the input.

[0047] After receiving the determined path (S206), the device 100 requests (also referred to as "request 1") the AI ​​model (also referred to as "generative AI model (l)"), which is the generative AI model, to generate API documentation corresponding to the API code for each API code (S207). After the generative AI model (l) creates technical documentation (S208), the device 100 receives and stores the technical documentation (S209).

[0048] It is preferable that request l include all root files whose paths have been determined. It is possible to determine one or more root files associated with each API code and include only the determined root files in request l. However, since the number of root files is not enormous even without this determination, including all code contained in all root files in request l can improve accuracy without significantly slowing down the speed of generating technical documentation. Even when not creating API documentation, it is also possible to additionally determine the paths of one or more files other than code and include all or part of the contents of those files in request l or the instructions included in request l.

[0049] If the purpose is to generate test cases, it is preferable that the description acquired from the user terminal 110 include a test perspective and a test case template. The device 100 can create a prompt for test case generation, including the described test perspective and template, and issue a request including the prompt. If the device 100 has previously acquired the test perspective and test case template, the device 100 can create a prompt using the test perspective and template in response to acquiring input related to the test case as the technical document to be created from the user terminal 110. At least one of the test perspective and the test case template may be included in the description or the prompt, and each may correspond to the type of test. In the case of test cases, in addition to creating technical documentation for each of one or more pieces of code for which a path has been determined, technical documentation can also be created for multiple pieces of code. That is, the device 100 can create technical documentation for at least a portion of one or more pieces of code for which a path has been determined.

[0050] The test case template includes a column for verification procedures, and may further include at least one of a screen name, a prerequisite, and a test perspective. A test perspective is a definition of at least one of one or more verification items included in the test. For example, the following test perspectives can be mentioned: For the normal test pattern, check the operation of a pattern in which only required fields are entered. The normal test pattern is a pattern in which all optional items are entered to check operation. The test pattern will leave each required item blank, full-width space, and half-width space, and check the validation operation. Boundary value testing is performed when expected behavior varies depending on input values.

[0051] FIG. 4 shows an example of code for creating a prompt included as part of the code for request l to a generative AI model (l) according to one embodiment of the present invention. In this example, the template "BUILD_API_FROM_CODE" sets the API code to the variable "code," the code in the route file to the variable "route," the format of the response to request l to the variable "response_introduction," and the module to which the API provided by the API code belongs to the variable "module." The variables "module" and "response_introduction" are not necessarily required. The variable "response_introduction" may also be set to the format of the response specified by the user. FIG. 5 shows an example of the template "BUILD_API_FROM_CODE" used in FIG. 4.

[0052] While Figure 2 distinguishes between generative AI model (k) and generative AI model (l), these may be the same generative AI model. In this specification, "AI model" refers to a machine learning model trained to predict an output for an input, and "generative AI model" refers to a large-scale language model (LLM) trained using text data to generate an output not included in the input. While LLMs employing 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. In this specification, whether "generative AI models" are the same is determined by whether the type of generative AI model specified by the user is the same. Taking the Open AI API example of GPT-4, if the value of the variable "model" is the same, they are considered to be the same generative AI model. If the first and second generative AI models are not the same, they may be provided on the same platform 130. 2, request k is followed by request l, and if generative AI model (k) and generative AI model (l) are the same generative AI model or are generative AI models provided on the same platform, these requests may be made by a single call to the API. Needless to say, request k and request l may each include multiple requests, and may include one or more processes performed by device 100 other than requests for generative AI models.

[0053] The device 100 then transmits technical document viewing information to the user terminal 110 for viewing at least one of the generated technical documents (S210). The technical document viewing information may be, for example, an HTML file, which the user terminal 110 can use to display a technical document viewing screen on its display screen. Alternatively, an application installed on the user terminal 110 may be run, and the received technical document viewing information may be used to display the technical document viewing screen within the application. Note that the "viewing screen" may take various forms, such as a web page, modal window, or pop-up window, when displayed on a web browser, or may be a single screen of the application when displayed within the application. In either case, any screen that includes an area for displaying the generated technical documents in a viewable manner is considered a viewing screen.

[0054] As such, automatic generation of technical documentation from source code bridges the gap between software development and documentation creation, significantly reducing the manual work typically required to create accurate and up-to-date technical documentation. Because the technical documentation to be generated may be redundant, it is not necessary to generate technical documentation for some files whose paths have been determined.

[0055] It should be noted that in the above embodiments, unless the word "only" is used, such as "based only on," "only in accordance with," "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 "always do b 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.

[0056] 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.

[0057] 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.

[0058] In this specification, we have explained the flow of making request l after request k, but in cases where the generative AI model is not necessarily used to determine the path, the generative AI model (l) may be referred to as the first generative AI model and request l as the first request. [Explanation of symbols]

[0059] 100 devices 101 Communications Department 102 Processing section 103 Storage section 104 databases 110 User Terminals 120 Source Code Management System 130 Platform

Claims

1. A method for generating technical documentation corresponding to source code managed by a code management system, The steps include receiving repository information relating to the repository where the aforementioned source code is managed, Steps to obtain input related to technical documents, The steps include determining the paths of one or more codes related to the input from the repository information, A first request is made to a first AI model, which is a generating AI model, to generate technical documentation corresponding to at least a portion of the one or more codes mentioned above. The steps include storing one or more generated technical documents and Includes.

2. The method according to claim 1, The above specification is a user-defined statement.

3. The method according to claim 2, The above description is a message entered into the chat screen displayed on the user's terminal used by the user.

4. The method according to claim 1, The aforementioned specification is the selection of the type of technical document to be generated.

5. A method according to any one of claims 1 to 4, wherein the determination step includes making a second request to a second AI model, which is a generating AI model, to determine the paths of the one or more codes from the repository information.

6. A method according to any one of claims 1 to 5, The aforementioned determination is made using the directory structure of the repository.

7. A method according to any one of claims 1 to 6, The technical documentation corresponding to the aforementioned code is the API documentation.

8. A method according to any one of claims 1 to 6, The technical documentation corresponding to the aforementioned code is the business logic.

9. A method according to any one of claims 1 to 6, The technical documentation corresponding to the aforementioned code is the API documentation.

10. A method according to any one of claims 1 to 6, The technical documentation corresponding to the aforementioned code is a test case.

11. A program for causing a computer to perform a method for generating technical documentation corresponding to source code managed in a code management system, wherein the method is: The steps include receiving repository information relating to the repository where the aforementioned source code is managed, Steps to obtain input related to technical documents, The steps include determining the paths of one or more codes related to the input from the repository information, A first request is made to a first AI model, which is a generating AI model, to generate technical documentation corresponding to at least a portion of the one or more codes mentioned above. The steps include storing one or more generated technical documents and Includes.

12. A device for generating technical documentation corresponding to source code managed by a code management system, Receive repository information regarding the repository where the aforementioned source code is managed, Obtain input related to technical documents, From the repository information, determine the paths of one or more codes related to the input. A first request is made to the first AI model, which is a generating AI model, to generate technical documentation corresponding to at least a portion of the one or more codes mentioned above. It is configured to store one or more generated technical documents.

Images