Apparatus, method and program for supporting technical documentation of software

Abstract

To improve efficiency by applying a generation AI model in an invention for supporting the preparation of a technical document necessary for the development of software.SOLUTION: In order to support technical documentation of software, one or more use cases occurring in the software are acquired, and for at least one of the use cases, a request including an instruction to generate a plurality of tasks corresponding to the use case is made to a generative AI model. As a result, it is possible to divide the use case into smaller unit tasks and appropriately assign the work related to each task according to the ability of the developer or the like.SELECTED DRAWING: Figure 2

Description

[Technical Field]

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

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

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

[0004] [Patent Document 1] Patent No. 7503700 Summary of the Invention [Problem to be solved by the invention]

[0005] As described above, software development involves many steps and involves many members, beginning with customer interviews, and therefore there has always been a demand for greater efficiency. As shown in Patent Document 1, the applicant has achieved greater efficiency in the process of creating technical documentation by using a generative AI model, the capabilities of which have improved significantly in recent years, but there is a demand for further improvement in this efficiency.

[0006] The present invention has been made in consideration of these points, and its objective is to achieve efficiency by applying a generative AI model to an apparatus, method, or program for supporting the creation of technical documentation required for software development. [Means for solving the problem]

[0007] In order to achieve this object, a first aspect of the present invention is a method for supporting the creation of technical documentation for software, comprising the steps of: acquiring one or more use cases occurring in the software; creating a first instruction for generating a plurality of tasks corresponding to at least one of the one or more use cases; and making a first request including the first instruction to a first generative AI model; and storing the generated tasks.

[0008] Also, a second aspect of the present invention is a method of the first aspect, further comprising a step of making a second request to a second generative AI model, the second request including second instructions to generate one or more business logic or API documents corresponding to each of the generated plurality of tasks.

[0009] Furthermore, a third aspect of the present invention is a method of the first aspect, further comprising the steps of receiving modifications to at least some of the generated tasks, and making a second request to a second generative AI model, the second request including second instructions to generate one or more business logic or API documents corresponding to the modified tasks modified based on the modifications.

[0010] Furthermore, a fourth aspect of the present invention is a method of any one of the first to third aspects, wherein the first instruction includes a constraint that the number of API endpoints included in the generated task is one or less or two or less.

[0011] Also, a fifth aspect of the present invention is a method of any one of the first to fourth aspects, wherein the plurality of tasks includes one or more tasks for a front end and one or more tasks for a back end.

[0012] A sixth aspect of the present invention is the method of the fifth aspect, wherein the task for the front end includes UI information relating to one or more UI components.

[0013] A seventh aspect of the present invention is the method of the sixth aspect, wherein the UI information includes criteria that the one or more UI components must satisfy.

[0014] An eighth aspect of the present invention is the method according to the sixth aspect, wherein the UI information includes a standard that must be satisfied by a function of at least one of the one or more UI components.

[0015] A ninth aspect of the present invention is the method of the fifth aspect, wherein the task for the backend includes API information relating to an API endpoint.

[0016] A tenth aspect of the present invention is a method according to the fifth or ninth aspect, wherein the task for the backend includes criteria that must be met when processing data sent or received by communication with the UI.

[0017] Furthermore, an 11th aspect of the present invention is a method of any one of the 1st to 10th aspects, wherein the first instruction includes a URL of a UI image associated with a use case that is the subject of the first request or an identifier corresponding thereto.

[0018] A twelfth aspect of the present invention is the method according to the eleventh aspect, wherein the URL is a URL provided by a design tool on the Internet.

[0019] A thirteenth aspect of the present invention is the method according to any one of the first to twelfth aspects, further comprising the step of assigning at least some of the generated tasks to a plurality of developers, respectively.

[0020] In addition, a 14th aspect of the present invention is a program for causing a computer to execute a method for assisting in the creation of technical documentation for software, the method including the steps of acquiring one or more use cases that occur in the software, creating a first instruction for generating a plurality of tasks corresponding to at least one of the one or more use cases, making a first request including the first instruction to a first generative AI model, and storing the generated plurality of tasks.

[0021] Furthermore, a fifteenth aspect of the present invention is an apparatus for assisting in the creation of technical documentation for software, configured to acquire one or more use cases that occur in the software, create a first instruction for generating a plurality of tasks corresponding to at least one of the one or more use cases, make a first request including the first instruction to a first generative AI model, and store the generated plurality of tasks. [Effects of the Invention]

[0022] According to one aspect of the present invention, in order to assist in the creation of technical documentation for software, one or more use cases that arise in the software are obtained, and for at least one of the use cases, a request is made to a generative AI model that includes instructions to generate multiple tasks corresponding to the use case.This makes it possible to divide the use cases into smaller tasks and appropriately assign the work related to each task to developers according to their capabilities, etc. [Brief explanation of the drawings]

[0023] [Figure 1] 1 is a diagram illustrating a system according to one embodiment of the present invention. [Figure 2] FIG. 1 is a diagram illustrating a method flow according to one embodiment of the present invention. [Figure 3] FIG. 1 is a diagram illustrating a use case at check-in of an attendance management system according to an embodiment of the present invention. [Figure 4] FIG. 10 is a diagram showing an example of a UI at check-in in the attendance management system according to one embodiment of the present invention. [Figure 5] FIG. 10 illustrates an example of a prompt that may be included as part of code to request task creation according to one embodiment of the present invention. [Figure 6A] FIG. 10 is a diagram showing a front-end ticket based on a use case at check-in in the attendance management system according to one embodiment of the present invention. [Figure 6B] FIG. 10 is a diagram illustrating a back-end ticket based on a use case at check-in in the attendance management system according to one embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION

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

[0025] 1 shows an apparatus according to one embodiment of the present invention. To support the creation of technical documentation required for software development, apparatus 100 communicates with a user terminal 110 used by a user and a platform 120 that provides a generative AI model via an IP network such as the Internet. While the generative AI model is described as being provided by platform 120 that can communicate with apparatus 100 as an example, an application for providing the generative AI model can also be executed on apparatus 100, so that the generative AI model can be provided by apparatus 100.

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

[0027] First, the device 100 acquires one or more use cases arising in the software from the user terminal 110 (S201). Considering a time attendance management system, an example of a use case at check-in is shown in FIG. 3. The use case displayed on the screen 300 shown in FIG. 3 is a natural language description of the behavior at check-in in the time attendance management system, and includes items such as actor and flow, and may further include at least one of precondition, postcondition, and alternative flow. The use case may also include an item such as UI component. The "UI component" item describes one or more UI components included in the UI associated with the use case. While FIG. 3 provides headings for each item, these are not necessarily required.

[0028] In this example, the actor is an employee. The prerequisites are that the employee be registered in the attendance management system and be logged in. The postconditions are that the employee's check-in time be recorded in the system and that the employee's current status be updated to "Checked in." Additionally, an alternative flow is described: if the employee has already checked in, the "Check-in" button is disabled. The UI components included in the UI for implementing this use case, such as the navigation bar, navigation links, cards, date and time, the "Check-in" button, and the status indicator, are also described as UI components. The use case then describes the flow, or the series of system behaviors. Specifically, when an employee sees the current date and time, their name, and title displayed on the attendance management system interface, and clicks the "Check-in" button, the system logs the check-in time and changes the employee's status to indicate that they have already checked in. While this uses case describes the check-in process, each use case that arises in the software being developed can be described in a similar manner.

[0029] In addition to directly receiving and acquiring one or more use cases arising in the software being developed, device 100 may also receive explanatory data that describes the software and, based on the explanatory data, cause a generative AI model or other AI model to generate a natural language description of one or more use cases arising in the software. For example, the explanatory data may be in text format, image format, video format, or any combination thereof. Herein, the term "AI model" refers to a machine learning model that has been trained to be able to predict an output for an input, and the term "generative AI model" refers to a large-scale language model (LLM) that has been trained using text data to be able to generate an output for an input that is not included in the input.

[0030] In addition to one or more use cases, the device 100 may acquire a UI image representing a UI for realizing at least one of the use cases. FIG. 4 is an example of a UI image corresponding to the use case shown in FIG. 3. A check-in screen 400 includes the UI components described in the use case shown in FIG. 3. For example, the device 100 may acquire the UI image by receiving a URL of the UI image or an identifier corresponding thereto and accessing the URL. The URL may be, for example, a URL provided by a design tool on the Internet.

[0031] Next, for at least one of the one or more acquired use cases, the device 100 creates an instruction (hereinafter also referred to as a "first instruction") to generate a plurality of tasks corresponding to the use case (S202). The plurality of tasks preferably includes one or more tasks for the front end and one or more tasks for the back end. By distinguishing between the two, it becomes possible to appropriately assign coding based on technical documentation corresponding to the use case or reviewing code automatically generated based on the technical documentation to multiple developers according to their respective capabilities, etc.

[0032] Here, "front end" refers to the part of the software that directly interacts with the user, such as an application for providing a UI, while "back end" refers to the part of the software that does not directly interact with the user, such as an application for managing a database or processing data on a server. "Tasks for the front end" simply describe the behavior of an application for the front end, which is an application that directly interacts with the user, and may also include descriptions of behavior that does not directly interact with the user. "Tasks for the back end" simply describe the behavior of an application for the back end, which is an application that does not directly interact with the user, and may also include descriptions of behavior that does directly interact with the user.

[0033] FIG. 5 shows an example of an instruction called a prompt included as part of the code for a first request for task generation according to one embodiment of the present invention. In this prompt, the variable {use_case} is set to a use case based on which multiple tasks will be generated, and the variable {screen_image} is set to a URL for a UI image representing the UI associated with the use case. Providing a UI image can reduce the possibility that tasks for the front end will deviate from the development intent. In addition, in this prompt, the variable {response_example} can be set to a template for the multiple tasks to be generated.

[0034] In addition, the Pronto imposes constraints such as limiting each ticket to two API endpoints, describing details necessary for developers, front-end tickets including UI information about UI components, and back-end tickets including API information about API endpoints, but the first instruction does not necessarily include all of these. In Figure 5, the term "ticket" is used instead of "task."

[0035] Next, the device 100 makes a first request including the created first instruction to the generative AI model (hereinafter also referred to as the "first generative AI model") (S203). As a generative AI model, an LLM that applies the Transformer architecture is particularly preferable, but it is expected that the name of the architecture will change as technology advances. Therefore, in this specification, the term "Transformer architecture" encompasses architectures that use 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 types of the generative AI models are the same. In the example of the OpenAI API, if the value of the variable "model" is the same, it is expressed as the same generative AI model.

[0036] The first request can be made by executing code for calling the OpenAI API using the first instruction as input. The OpenAI API is an example, and other APIs may be used. The code for making the first request may use any programming language. The code for making the first request may be stored in the storage unit 103, and the device 100 may acquire the code and execute the code obtained by setting required values ​​to variables included in the code.

[0037] The device 100 then stores the generated task or tasks (S204) and may transmit them to the user terminal 110 for viewing as necessary. The generated tasks can be viewed by transmitting task viewing screen display information, or more simply, task display information, from the device 100 to the user terminal 110, for example, as an HTML file. The task display information can be used to display a task viewing screen on a web browser on the user terminal 110. Alternatively, an application installed on the user terminal 110 can be run, and the received task display information can be used to display a task viewing screen on the application. The generated tasks may also be output to a command line prompt on the user terminal 110. Note that the "viewing screen" can take various forms, such as a web page, modal window, or pop-up window, when displayed on a web browser. When displayed on another application, it can be a single screen of the application. In either case, any screen that includes an area for displaying the generated tasks in a viewable manner is considered a viewing screen. Similar techniques can be applied to other screens mentioned in this specification.

[0038] The task viewing screen can be configured to allow editing of the displayed tasks. When a modification is received from the user terminal 110 for at least one of the generated tasks, the task viewing screen can be configured to allow editing of the displayed tasks. stomach The following process will be performed on the modified task.

[0039] FIG. 6A shows a front-end ticket based on a check-in use case of an attendance management system according to one embodiment of the present invention, and FIG. 6B shows a back-end ticket based on the same use case. The front-end and back-end applications each describe different criteria to be met, helping developers assigned to each ticket clearly understand their work. Specifically, the former describes criteria to be met by one or more UI components included in the UI, while the latter describes API information related to API endpoints as well as criteria to be met by processing data sent or received through communication with the UI. More specifically, the former includes criteria to be met by the functions, visual features, etc. of UI components included in the UI.

[0040] The device 100 creates instructions (hereinafter also referred to as "second instructions") to generate one or more technical documents corresponding to each generated task (S205), makes a request (hereinafter also referred to as "second request") including the second instructions to the generative AI model (hereinafter also referred to as "second generative AI model") (S206), and stores the generated one or more technical documents (S207). While specific examples of the second instructions are not provided, in light of the disclosure of the first instructions in this specification, it is possible to create appropriate prompts depending on the type of desired technical document, such as business logic, API documentation, or database design. The second request can be made by executing code obtained by setting required values ​​to variables included in the code for the second request including the prompt. Here, "business logic" refers to logic for processing data sent or received through communication with a UI based on business requirements. Here, "logic" refers to a series of instructions. Furthermore, "API documentation" refers to a document describing the functions and usage of an API.

[0041] While FIG. 2 distinguishes between the first and second generative AI models, they may 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 120. In the example of FIG. 2, a first request is followed by a second request. If the first and second generative AI models are the same generative AI model or provided on the same platform, these requests may be made by a single call to the API. Furthermore, the first and second requests may each include multiple requests and may include one or more processes performed by device 100 other than the request for the generative AI model.

[0042] The device 100 may assign at least some of the tasks generated based on the use cases to a developer. If the developer's job is coding, the developer performs coding based on the assigned task. If the developer's job is reviewing automatically generated code, the developer reviews the code. The developer to whom the task is assigned may also review technical documentation generated based on the task.

[0043] As described above, in order to support the creation of technical documentation for software, one or more use cases that arise in the software are acquired, and for at least one of the use cases, a request including an instruction to generate multiple tasks corresponding to the use case is sent to a generative AI model, which makes it possible to divide the use case into smaller units of tasks and appropriately assign work related to each task to developers according to their capabilities, etc. This reduces the complexity of software development that arises when many people are involved, and improves the efficiency of project management of development projects.

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

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

[0046] 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. [Explanation of symbols]

[0047] 100 devices 101 Communications Department 102 Processing section 103 Storage section 110 User Terminals 120 Platform 300 Use Case Viewing Screen 400 Check-in screen 600A Front-end Task View Screen 600B Backend task viewing screen

Claims

1. 1. A method for assisting in the creation of technical documentation for software, comprising: obtaining one or more use cases occurring in the software; creating a first instruction for generating, for at least one of the one or more use cases, a plurality of tasks corresponding to the use case; making a first request including the first instruction to a first generative AI model; storing the generated tasks; Includes:

2. 10. The method of claim 1, The method further includes making a second request to a second generative AI model, the second request including second instructions to generate one or more business logic or API documents corresponding to each of the generated plurality of tasks.

3. 10. The method of claim 1, receiving modifications to at least some of the generated tasks; making a second request to a second generative AI model, the second request including second instructions to generate one or more business logic or API documents corresponding to the modified task based on the modification; Further includes:

4. 4. A method according to any one of claims 1 to 3, comprising: The first instruction includes a constraint that the number of API endpoints included in the generated task is one or less, or two or less.

5. 5. A method according to any one of claims 1 to 4, comprising: The plurality of tasks includes one or more tasks for the front end and one or more tasks for the back end.

6. 6. The method of claim 5, A task for the front end includes UI information about one or more UI components.

7. 7. The method of claim 6, The UI information includes criteria that the one or more UI components must meet.

8. 7. The method of claim 6, The UI information includes criteria that functionality of at least one of the one or more UI components must meet.

9. 6. The method of claim 5, The task for the backend includes API information about the API endpoint.

10. 10. The method of claim 5 or 9, The tasks for the backend include criteria that must be met for processing data sent or received by communication with the UI.

11. 11. The method according to claim 1, wherein the first instruction includes a URL or a corresponding identifier of a UI image associated with a use case that is the subject of the first request.

12. 12. The method of claim 11, The URL is a URL provided by the design tool on the Internet.

13. 13. A method according to any one of claims 1 to 12, comprising: The method further includes assigning at least some of the generated tasks to a plurality of developers, respectively.

14. A program for causing a computer to execute a method for supporting the creation of technical documentation for software, the method comprising: obtaining one or more use cases occurring in the software; creating a first instruction for generating, for at least one of the one or more use cases, a plurality of tasks corresponding to the use case; making a first request including the first instruction to a first generative AI model; storing the generated tasks; Includes:

15. An apparatus for supporting the creation of technical documentation for software, comprising: obtaining one or more use cases that occur in the software; creating a first instruction for generating a plurality of tasks corresponding to at least one of the one or more use cases, and making a first request including the first instruction to a first generative AI model; The generated tasks are stored.

Images