Project-customized code generation ai system and method thereof

The AI system addresses code inconsistency and integration issues by learning project-specific contexts and applying changes sequentially, ensuring high-quality code and efficient development processes.

KR103043916B1Active Publication Date: 2026-11-06BLOOM AI CO LTD
View PDF 3 Cites 0 Cited by

Patent Information

Application Number
KR1020250203444
Authority / Receiving Office
KR · KR
Patent Type
Patents
Current Assignee / Owner
Filing Date
2025-12-18
Publication Date
2026-11-06
Estimated Expiration
2045-12-18

AI Technical Summary

Technical Problem

Existing AI code generation tools fail to fully adhere to project-specific conventions, leading to inconsistent code, require manual work, and cause development delays due to incomplete multi-file operations and frequent server restarts, while external tools complicate integration into existing projects.

Method used

An AI system with a context learning unit that analyzes project structure and UI libraries, generates code conforming to project rules via natural language commands, and applies changes sequentially through a job queue management system to prevent conflicts, using a memory buffer for batch processing.

Benefits of technology

Ensures high-quality, consistent code generation, reduces development time, and allows non-developers to safely contribute, enhancing productivity and collaboration by minimizing manual tasks and errors.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 112025143697865-PAT00001_ABST
    Figure 112025143697865-PAT00001_ABST
Patent Text Reader

Abstract

An AI system for generating project-specific code is injected into a target project via a Software Development Kit (SDK) and includes a context learning unit that scans the source code of the target project and automatically analyzes context information including project structure, coding style, and UI libraries used. Additionally, the system is characterized by comprising a user interface unit that receives natural language commands for code generation or modification from a user, an AI generation unit that generates customized code conforming to the rules and conventions of the target project based on the analyzed context information and the input natural language commands, and a code application unit that applies the generated customized code to the file system of the target project.
Need to check novelty before this filing date? Find Prior Art

Description

Technology Field

[0001] The present invention relates to a software development support system using artificial intelligence (AI) technology, and more specifically, to an AI-based automatic code generation system and method that automatically learns the context of a specific software project and generates code that 100% conforms to the rules and style of the project. The present invention applies AI technology to the specific problem of 'code generation' and has the technical feature of learning the context (rules, style, structure, etc.) using data in the form of project source code and generating new code based thereon. Background Technology

[0002] Recently, the adoption of AI-based code generation tools has been actively taking place in the software development field. AI-based code assistants such as GitHub Copilot and Cursor, as well as no-code / low-code platforms like Bolt and Webflow, are contributing to improved development productivity. However, these existing tools have limitations in fully complying with the unique coding standards, UI / UX guidelines, architecture, and folder structures specific to each company and project, leading to additional manual work and rework during the development process.

[0003] In particular, existing AI code generation tools have the following problems. First, they compromise code consistency by generating components from libraries other than the project's specific UI library (e.g., Semantic UI). Second, in complex tasks requiring simultaneous modification of multiple files (menu files, screen files, path configuration files, etc.), such as adding website menus, they frequently process only some files while omitting the rest. Third, every time the AI ​​modifies code, the development server restarts multiple times, causing delays and errors in the development environment and reducing productivity.

[0004] Furthermore, external no-code / low-code tools such as Bolt or Webflow have their own proprietary development environments, making it difficult to integrate the generated output into the existing project's folder and file structure. Consequently, the "transferring" process—where developers copy and paste the generated code and modify it to fit the project—becomes essential, which undermines code consistency and maintainability.

[0005] These issues act as the primary factors that make it difficult to fully utilize AI code generation tools in actual corporate environments, despite their potential to increase development efficiency. Consequently, there is a growing need for a customized AI code generation system that supports non-developers in safely creating and modifying screens while fully adhering to the project's unique rules and styles. The problem to be solved

[0007] The problem that the present invention (AI code automatic generation system) aims to solve is as follows.

[0008] First, this addresses the problem where existing AI code generation tools or external no-code / low-code tools fail to automatically learn and 100% adhere to project-specific conventions, such as unique code styles, UI libraries (e.g., generating Material-UI components for projects using Semantic UI), file / folder structures, routing, and menu structures, in order to generate code. Consequently, the generated code compromises project consistency and has limitations in that it requires additional manual work.

[0009] Second, when implementing complex features (e.g., new menus / pages), AI often incompletely handles or misses tasks that require modifying multiple files simultaneously, leading to inefficient multi-file operations. Additionally, frequent file modifications cause the development server to restart multiple times and pages to refresh, hindering development productivity and causing slowdowns.

[0010] Third, it is difficult for planners or designers without coding knowledge to directly and safely create or modify website screens. With existing tools, there is a problem in that it is difficult to directly and consistently reflect the results of design tools (e.g., Figma) into actual project code without developer intervention. The present invention aims to effectively solve these problems to dramatically improve the productivity and quality of software development. means of solving the problem

[0012] An AI system for generating project-specific code according to one aspect of the present invention for solving the above problem includes a context learning unit that is injected into a target project via a Software Development Kit (SDK) and automatically analyzes context information including project structure, coding style, and UI libraries used by scanning the source code of the target project. Additionally, it includes a user interface unit that receives natural language commands for code generation or modification from a user, an AI generation unit that generates customized code conforming to the rules and conventions of the target project based on the analyzed context information and the input natural language commands, and a code application unit that applies the generated customized code to the file system of the target project.

[0013] The above system further includes a job queue management unit that defines the natural language command input through the user interface unit as an individual job, assigns a unique job identifier (Job ID), and manages it by registering it in a queue. The job queue management unit is characterized by preventing data access conflicts (race conditions) that may occur during the process of the code application unit applying code to the file system by controlling that only one job at a time accesses the code application unit according to the order registered in the queue when simultaneous natural language commands are input from multiple users, and by determining the status information of the corresponding job as one of Pending, Processing, Done, or Failed according to the progress stage of each job and updating it in memory in real time.

[0014] The code application unit described above has the characteristic of temporarily storing all changes in a memory buffer and then writing them collectively to the file system of the target project in the final stage when the modification or creation of multiple files is requested by the AI ​​generation unit.

[0015] The context learning unit analyzes the menu structure and routing rules of the target project, and the AI ​​generation unit has the characteristic of simultaneously generating or modifying multiple files including source code, route settings, and menu items for a new page based on the menu location selected by the user through the user interface unit.

[0016] The above user interface unit receives reference information regarding specific design elements of an external design tool, and the AI ​​generation unit is characterized by converting the design corresponding to the input reference information to match the UI library and coding style included in the analyzed context information to generate UI component code.

[0017] The above user interface unit provides a function that allows a user to select a specific UI element (visual picking) on ​​a screen rendered on a web browser, and the above AI generation unit is characterized by automatically identifying the location of the selected UI element within the source code and processing the natural language command based on the identified location.

[0018] Separately, a method for generating project-specific code executed by a computer comprises: (a) a step of being injected into a target project via an SDK (Software Development Kit) to scan the source code of said target project and automatically analyze context information including project structure, coding style, and UI libraries used; (b) a step of receiving natural language commands from a user for code generation or modification; (c) a step of generating customized code that conforms to the rules and conventions of said target project based on the analyzed context information and said input natural language commands; and (d) a step of applying said generated customized code to the file system of said target project.

[0019] Step (d) above is characterized by the fact that, if modification or creation of multiple files is required as a result of Step (c), all changes are temporarily stored in a memory buffer and then written collectively to the file system of the target project in the final step.

[0020] Step (a) above further includes analyzing the menu structure and routing rules of the target project, and Step (c) above is characterized by automatically generating source code, route settings, and menu items for a new page based on the menu location selected by the user. Effects of the invention

[0022] The present invention overcomes the limitations of existing AI code generation tools and no-code / low-code tools, dramatically improves development productivity and code quality, and enables safe development participation by non-developers, thereby providing the following effects.

[0023] In terms of maximizing development productivity and efficiency, it offers overwhelming reductions in development time. By drastically reducing the N-times of Webpack restarts and page refreshes that occur when modifying or creating multiple files simultaneously to just a single one using memory buffering (DryRun), it dramatically cuts total waiting time from 20 seconds to 5 seconds, thereby saving development time. This time reduction minimizes repetitive waiting time for developers, allowing them to dedicate more time to actual problem-solving and creative work. It also minimizes repetitive manual tasks. AI automatically synchronizes and processes tasks spanning multiple files, such as adding menus or routes, and completely eliminates the inefficient process of developers manually transcribing designers' work by directly converting Figma designs into actual project code. This reduces hassle during the development process and lowers the likelihood of errors, thereby improving overall development speed. Easy installation and integration are also advantages. It can be easily applied to any project with just a single line of SDK script injection, minimizing the effort required for initial setup. This lowers the barrier to system adoption and allows for flexible application across various projects.

[0024] It generates project-specific code to dramatically improve code quality and consistency. AI independently learns the project's UI libraries (e.g., Semantic UI), layout structure, coding styles (functional / class-based, styled-components), folder / file naming conventions, and menu / route tree structures to generate code that fully adheres to the project's rules (style, structure, conventions). Unlike existing AI tools that showed a style compliance rate of 50–60%, this guarantees consistently high-quality code. As a result, the generated code is of a quality that is almost indistinguishable from manual code. Furthermore, consistency is maintained through reference-based generation. By generating new code that references existing pages or components, the project's unique coding style and patterns are automatically applied, enabling even junior developers to write senior-level code. This raises the overall code quality of the team and reduces the burden of code reviews. It also resolves the issue of using inappropriate libraries. It resolves the issue where existing AI tools create UI components that are not used in a project (e.g., generating Material-UI components in a Semantic UI project) and always generates code based on the correct UI library. This enhances project stability by preventing the addition of unnecessary dependencies or style conflicts.

[0025] In terms of promoting safe development participation and collaboration for non-developers, it supports secure screen modification for them. It enables planners and designers without coding knowledge to safely create and modify website screens through an intuitive interface (menu tree selection, Visual Picker, etc.). This allows personnel outside the development team to directly participate in development, significantly enhancing inter-departmental collaboration efficiency. Intuitive UI-based code generation is possible. Through UI creation by clicking screen elements and the Figma design import feature, even non-developers can easily configure and modify desired screens. This shortens the feedback loop from idea conception to actual implementation, thereby accelerating service development speed.

[0026] In terms of ensuring system stability and transparency, it supports stable multi-file processing. Through memory buffering and a Job Queue, it reliably processes multiple file modification requests and ensures the stability of the entire flow without intermediate build repetitions. This maintains data integrity even in the event of system errors and prevents transitions to an incomplete state. By introducing a Job Queue system, this invention controls the system to process code generation requests sequentially, even if multiple developers or designers request them simultaneously. This fundamentally prevents conflicts or data corruption caused by simultaneous write operations to the file system. Furthermore, by clearly managing and providing real-time status information for each task (Pending, Processing, Done), it alleviates user anxiety during long processing times and offers a predictable user experience (UX). It provides clear progress updates. Through a two-stage workflow (analysis and planning → step-by-step execution), it clearly presents the progress of each stage of the task to the user, thereby improving system reliability and ease of use. Users can check the AI's task progress status in real time and obtain a predictable development experience. Error prevention and verification are also possible. By utilizing the Tool Use API's DryRun mode, you can preview changes before saving them to actual files to prevent potential errors, and easily manage change history by linking directly to Git commits. This supports developers in thoroughly reviewing changes before approving the final version, minimizing unexpected bugs or conflicts.

[0027] The effects of the present disclosure are not limited to those mentioned above, and other unmentioned effects will be clearly understood by a person skilled in the art from the description below. Brief explanation of the drawing

[0029] Figure 1 shows the overall system configuration diagram of a project-customized code generation AI system according to the present invention. Figure 2 shows a detailed flowchart of the main functions of an AI system according to the present invention. FIG. 3 is a flowchart showing the overall procedure of a project-customized code generation method according to the present invention. FIG. 4 is a flowchart illustrating the detailed operation of the code application unit according to the present invention, in particular the memory buffering and batch recording process. FIG. 5 is a flowchart illustrating in detail the menu / routing-based code generation process according to the present invention. FIG. 6 is a block diagram and flowchart showing the flow of UI component code generation through external design tool integration according to the present invention. FIG. 7 is a block diagram and flowchart illustrating the code processing flow through UI element selection (Visual Picking) according to the present invention. FIG. 8 is a screen configuration diagram showing an example screen of a user interface of an AI system according to the present invention, in particular a menu creation scenario. Specific details for implementing the invention

[0030] Specific structural or functional descriptions regarding embodiments according to the concept of the present invention disclosed herein are provided merely for the purpose of explaining embodiments according to the concept of the present invention, and embodiments according to the concept of the present invention may be implemented in various forms and are not limited to the embodiments described herein.

[0031] The terms used in this specification will be briefly explained, and the present invention will be described in detail. The terms used in this specification have been selected to be as generally used as possible, taking into account their functions in the present invention; however, these terms may vary depending on the intent of those skilled in the art, case law, the emergence of new technologies, etc. Additionally, in specific cases, terms have been arbitrarily selected by the applicant, and in such cases, their meanings will be described in detail in the relevant description of the invention. Therefore, the terms used in the present invention should be defined not merely by their names, but based on their meanings and the overall content of the present invention.

[0032] In this specification, terms such as "comprising" or "having" are intended to indicate the existence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof. Furthermore, in this specification, terms including ordinal numbers, such as "first," "second," etc., may be used to describe various components, but said components are not limited by said terms. Such terms are used solely for the purpose of distinguishing one component from another.

[0033] As illustrated in FIG. 1, the project-customized code generation AI system (10) largely comprises a context learning unit (110), a user interface unit (120), an AI generation unit (130), and a code application unit (140). Each of these components can organically link to learn the unique characteristics of the target project (20), generate a customized code (80) that is 100% compatible with the target project (20) based on the natural language command (60) of the user (30), and perform a series of processes to safely apply the code to the file system (21) of the target project.

[0034] First, the context learning unit (110) can perform the role of automatically analyzing and learning context information of the target project (20). Specifically, the context learning unit (110) can be injected into the target project (20) in the form of an SDK (Software Development Kit) to scan the source code of the target project (20). Through this scanning process, various context information (70), such as the project structure, coding style, and UI libraries used of the target project (20), can be extracted and analyzed. The context information (70) extracted here can be utilized as core input data required for the AI ​​generation unit (130) to generate customized code (80). The context learning unit (110) can maintain the latest state of context information (70) by monitoring the source code of the target project (20) periodically or on an event basis. This ensures that the AI ​​system (10) always generates code based on the latest version of the project state, thereby maximizing the accuracy and validity of code generation.

[0035] The user interface unit (120) is responsible for the interaction between the user (30) and the project-specific code generation AI system (10). The user (30) can input natural language commands (60) for code generation or modification through the user interface unit (120). Natural language commands (60) refer to requests expressed in everyday language, such as "create a new user management page" or "change the color of this button." The user interface unit (120) can serve as a channel to effectively convey the user's intention to the AI ​​system (10) by receiving these natural language commands (60) and transmitting them to the AI ​​generation unit (130). Additionally, the user interface unit (120) can process various forms of user input, such as reference information (90) from an external design tool (121) to be described later or UI element selection information (91) from a web browser (50), which can significantly improve the convenience of the developer's work.

[0036] The AI ​​generation unit (130) is the part responsible for the core intelligence of the project-customized code generation AI system (10). The AI ​​generation unit (130) can generate customized code (80) that 100% conforms to the unique rules and conventions of the target project (20) based on context information (70) analyzed from the context learning unit (110) and natural language commands (60) received from the user interface unit (120). Here, the customized code (80) can include code that goes beyond simply functioning code and has a consistent style, structure, and logic that blends perfectly with the code already existing in the target project (20). For example, it can generate code that automatically complies with the component structure of a specific framework (e.g., React, Vue, Angular), TypeScript interface definitions, ESLint rules, Prettier formatting, etc. This can guarantee quality equal to or greater than that of writing code manually. The AI ​​generation unit (130) can support all code modification operations desired by the developer by including the ability to modify existing code according to the user's command, in addition to simply generating new code.

[0037] The code application unit (140) performs the role of safely and efficiently applying the customized code (80) generated by the AI ​​generation unit (130) to the file system (21) of the actual target project (20). The code application unit (140) does not simply paste the generated code, but can perform tasks such as creating files in the correct location within the file system (21) of the target project (20), safely modifying existing files, and adding dependencies if necessary. In particular, when multiple file changes are required, file I / O overhead can be reduced and the stability of the change operation can be guaranteed through a batch application method in which all changes are temporarily stored in a memory buffer (141) and then written to the file system (21) at once. This maintains the integrity of the file system (21) even in the event of a system error and can increase the stability of the development environment.

[0038] Through the close integration of these components, the project-specific code generation AI system (10) can significantly reduce the repetitive and complex coding work faced by the developer (30), maintain consistent code quality, and dramatically improve the efficiency of the entire development process. The user (30) clearly specifies the desired function through natural language commands (60), and the system (10) generates optimal customized code (80) based on the context (70) of the target project (20) and applies it to the target project's file system (21), thereby allowing the developer to focus on high-level idea conception and design.

[0039] FIG. 2 is a block diagram that more specifically explains the detailed functional modules of the context learning unit (110), user interface unit (120), AI generation unit (130), and code application unit (140) within the project-customized code generation AI system (10) presented in FIG. 1, as well as the data flow between them. While FIG. 1 showed the macroscopic configuration of the system, FIG. 2 shows in detail the interactions of the internal modules that constitute the core intelligence of the AI ​​system (10). In addition, it clearly shows the interactions with external entities such as the user (30), the target project (20), and the file system (21) of the target project.

[0040] The context learning unit (110) plays a key role in deeply understanding the current state and rules of the target project (20). The context learning unit (110) includes the following detailed modules.

[0041] The SDK (Software Development Kit, 111) is a software development kit used by the AI ​​system (10) of the present invention to access the internal structure of a target project (20) and read source code. The SDK (111) is injected into the build system, file system (21), or IDE (Integrated Development Environment) plugin of the target project (20) to collect information about the target project (20). This injection method requires only minimal changes to the target project (20) and can increase compatibility with various development environments.

[0042] The source code scanner (112) is a module that reads the actual source code files of the target project (20) after being injected into the target project (20) through the SDK (111). The source code scanner (112) can determine the scan targets based on a specific directory structure, file extensions (e.g., .js, .ts, .vue, .jsx, .tsx, .html, .css, .scss, .json, etc.), or the change history of a version control system such as Git. This reduces unnecessary file scanning and allows for efficient analysis of only the code that has changed, thereby reducing the system load. The scanned source code is passed to the context analyzer (113).

[0043] The context analyzer (113) is an intelligent module that extracts various context information (70) by deeply analyzing the source code received from the source code scanner (112). The context analyzer (113) identifies the following information through static code analysis, abstract syntax tree (AST) analysis, data flow analysis, dependency graph generation, etc.

[0044] The project structure allows you to understand the overall architecture of the project, including directory hierarchy, module organization, dependencies between files, build settings (e.g., Webpack, Vite settings), and folder and file naming conventions.

[0045] Coding style involves learning code writing principles agreed upon within the development team, such as indentation rules, variable / function / class naming conventions (e.g., camelCase, PascalCase, snake_case), comment styles, and code formatting. These rules can be accurately identified by analyzing configuration files of code linters and formatters like ESLint and Prettier.

[0046] The UI libraries used can identify UI component libraries such as Material UI, Ant Design, Chakra UI, Bootstrap, and Semantic UI, which are used alongside frameworks like React, Vue, and Angular, as well as their custom usage patterns. This ensures that the AI ​​generates UI component code suitable for the project.

[0047] The menu structure and routing rules can identify the application's navigation structure, URL routing settings, component information connected to each route, parameter processing methods, authentication and authorization rules, etc. (detailed explanation in Fig. 5).

[0048] Data models and API call patterns maintain consistency in data processing logic by analyzing communication methods with backend APIs, data formats, and state management patterns (e.g., Redux, Vuex, Zustand).

[0049] The custom component learns the definition and usage examples of UI components developed internally within the project, enabling the reuse of existing components or the creation of similar patterns when generating new code. The context analyzer (113) transmits these analysis results to the context information storage unit (114).

[0050] The context information storage unit (114) is a database or memory-based storage that stores and manages various context information (70) extracted from the context analyzer (113). The context information storage unit (114) may include indexing and caching functions so that the AI ​​generator (130) can efficiently query the latest context information (70) whenever needed. This can contribute to the AI ​​generator (130) quickly referencing the context information to generate code.

[0051] The user interface unit (120) performs the role of receiving natural language commands (60) from the user (30). The user (30) can input a request for code generation or modification in natural language form through a conversational interface, a text input field, etc. The input natural language command (60) is transmitted to the AI ​​generation unit (130).

[0052] The AI ​​generation unit (130) is responsible for the core intelligence of the project-customized code generation AI system (10) and generates / modifies customized code based on learned context and user commands. The AI ​​generation unit (130) includes the following detailed modules.

[0053] The code generation module (131) is an AI model that generates code for a new function based on context information (70) received from the context information storage unit (114) and natural language commands (60) received from the user interface unit (120). This module can generate optimal code by reflecting the coding style, structure, and library usage of the target project (20) based on a large-scale language model (LLM). For example, when given a command such as "create a new dashboard page" and the project's React + Material UI context, it generates component files and route settings suitable for the framework and library, and at this time, it can learn and reflect the layout pattern of the existing dashboard page or the method of using data visualization components.

[0054] The code modification module (132) is an AI model that modifies existing code by utilizing context information (70) and natural language commands (60). When a command such as “Change the text of this button to ‘Save’” is entered, the AI ​​generation unit (130) identifies the corresponding button within the target code file and modifies the text, while maintaining the button’s existing style or attributes. In particular, precise code modification can be performed by utilizing the location (71) within the source code of the UI element selected through the UI element selector (122) described in FIG. 7.

[0055] The design-code conversion module (133) (described in detail in FIG. 6) can convert reference information (90) input from an external design tool (121) into UI component code (80) that matches the UI library and coding style of the target project (20). This can reduce the gap between designers and developers and support the efficient coding of the design system.

[0056] The location identification module (134) can perform the role of identifying the exact location (71) within the source code of a UI element selected by the user on a web browser (50) (described in detail in FIG. 7). This enables code modification based on visual interaction.

[0057] The AI ​​generation unit (130) processes complex user requests through the collaboration of these modules and finally outputs customized code (80) to be applied to the target project (20).

[0058] A project-customized code generation AI system (10) according to one embodiment of the present invention may further include a job queue manager for reliably processing natural language commands (60) input simultaneously from multiple users.

[0059] The above job queue management unit assigns a unique job identifier (Job ID) to each natural language command (60) entered through the user interface unit (120) and manages it by registering it in a first-in, first-out (FIFO) queue. This is to prevent file system access conflicts or process race conditions that may occur when multiple users simultaneously request code generation or modification.

[0060] Specifically, the task queue management unit manages the progress status of each task in real time by classifying it into status values ​​such as 'Pending', 'Processing', 'Done', or 'Failed'. The user interface unit (120) periodically (Polling) checks the task status through the task identifier and can provide the user with visual feedback in stages, such as "Analyzing", "Code generating", and "Completed".

[0061] In addition, the above-mentioned job queue management unit ensures data integrity by controlling that only one job session at a time accesses the code application unit (140) and the memory buffer (141), thereby fundamentally blocking subsequent jobs from interfering before a preceding job completes file system changes.

[0062] The generated custom code (80) is transmitted to the code application unit (140).

[0063] The code application unit (140) plays the role of safely recording the customized code (80) received from the AI ​​generation unit (130) into the target project's file system (21). The code application unit (140) performs tasks such as creating, modifying, and deleting files, and can efficiently process multiple file changes by utilizing the memory buffer (141) which will be described in detail in FIG. 4. In this way, the AI ​​system (10) can support complete automation from the beginning to the end of the development workflow.

[0064] In conclusion, FIG. 2 can provide a detailed functional flow of how the AI ​​system (10) of the present invention understands a target project (20) (context learning unit 110), accepts user requirements (user interface unit 120), implements those requirements into code in accordance with the context (AI generation unit 130), and finally reflects them in the project (code application unit 140). This demonstrates the core mechanism of the present invention that goes beyond simply generating code snippets to ensure code consistency and development productivity throughout the project.

[0065] FIG. 3 is a flowchart illustrating the overall procedure from start to end of the project-customized code generation method according to the present invention. The present method clearly shows the steps in which the components of the project-customized code generation AI system (10) described in FIG. 1 and FIG. 2 interact sequentially or in parallel to perform the code generation and application process. The present method is executed by a computer and is largely composed of a context information analysis step (S100), a natural language command input step (S200), a customized code generation step (S300), and a code application step (S400). The present method starts at the 'START' node.

[0066] The context information analysis step (S100) is the core first step of the present invention and is performed by the context learning unit (110). This step may include the process of understanding the context of the project by analyzing the source code and related information of the target project (20). The SDK injection and source code scanning step (S101) is injected into the target project (20) through the SDK (111) of the context learning unit (110), and the source code scanner (112) scans all source code of the target project (20). This includes all files and directory structures of the project, and can identify the overall context of the project by analyzing even the commit history or build configuration files. Based on the scanned source code, the context analyzer (113) automatically analyzes context information (70) including the project structure (e.g., module organization, directory hierarchy, dependency management), coding style (e.g., indentation, variable / function / class naming rules, code formatting, comment conventions), and UI libraries used (e.g., frameworks and component libraries actually in use such as React, Material UI, Vue, Ant Design, etc.) (project structure analysis step (S102)). This analysis is performed through various techniques such as static analysis, Abstract Syntax Tree (AST) analysis, and data flow analysis, and can provide essential basic information that allows the code generated by the AI ​​to be perfectly integrated into the existing project.

[0067] In one embodiment, the context analyzer (113) can perform a 'context-based prompt automatic configuration algorithm' that statically analyzes the environment of a target project to derive optimal generation conditions. The algorithm can proceed in the following detailed steps.

[0068] The first step is library dependency analysis and UI prompt injection. The system parses the package manager file (e.g., package.json) located in the project's root directory to extract a list of installed third-party libraries. If the system detects a specific UI library, such as 'semantic-ui-react', within the dependencies field, it adds a natural language directive stating "This project uses Semantic UI React" to the internal prompt buffer (aiPrompt). Additionally, by merging detailed constraints such as "Import Button, Modal, Form, etc. from semantic-ui-react," it prevents the hallucination phenomenon where a general-purpose AI model randomly selects a UI library.

[0069] The second step is the quantitative analysis of code style and the setting of functional / class conditions. The system traverses the source code directories within the project and analyzes the implementation methods of components to generate quantitative statistical data. For example, if the proportion of functional components among all scanned components exceeds a pre-set threshold (e.g., 90%), it includes a directive to "write as functional components" in the prompt; if the usage rate of styled-components is high, it includes a directive to "style using styled-components."

[0070] Third is the step of identifying the common layout structure and enforcing the pattern. The system analyzes the ASTs of individual page components to identify the pattern of the top-level wrapper component. If the analysis reveals that the majority of pages are wrapped in a specific layout (e.g., CommonLayout), it automatically inserts a structural constraint in the prompt stating that "all pages must be wrapped in CommonLayout."

[0071] Fourth, the final prompt synthesis step. The individual context information collected through the above steps is synthesized into a single structured system prompt, such as "This project uses Semantic UI React. Use functional components and build it following the pattern above." and transmitted to the AI ​​generation unit (130).

[0072] The context analyzer (113) analyzes the menu configuration file, routing configuration file (e.g., routes.js, app-routing.module.ts), or specific patterns of the target project (20) to extract the application's menu structure and routing rules as additional context information (70) (menu / routing rule analysis step (S103) (described in detail in FIG. 5)). This information can play a decisive role in maintaining consistency with the existing navigation system when adding new pages or menu items. All analyzed context information (70) is stored and managed in the context information storage unit (114) (context information storage step (S104)). This information is subsequently used by the AI ​​generation unit (130) to generate custom code and can be updated periodically to always reflect the latest project status. As a result of this step, context information (70) is output.

[0073] The natural language command input step (S200) is performed by the user interface unit (120). In this step, the user (30) inputs natural language commands (60) for code generation or modification into the project-specific code generation AI system (10). The user (30) inputs text-based requests such as "Add a sign-up function," "Change the title of the current page to 'Service Status'," and "Add a new card-type component to the main screen" (natural language commands (60)). This allows the development process to be simplified by expressing one's intentions in natural language instead of the developer writing code directly. The user interface unit (120) can receive reference information (90) (e.g., component ID, style attribute, layout information) for specific design elements of an external design tool (121) such as Figma (design reference information input step (S210) (detailed description in FIG. 6)). This can be used to directly reflect the results of the designer's work into the development code. The user interface section (120) can receive UI element selection information (91) in which the user (30) visually selects a specific UI element on a screen rendered on a web browser (50) (UI element selection information input step (S220) (described in detail in FIG. 7)). This can increase intuitiveness by allowing the user to directly specify and modify elements visible on the screen without having to search for code directly. As a result of this step, a natural language command (60) (and reference information (90), UI element selection information (91) if necessary) is input.

[0074] The customized code generation step (S300) is a core step performed by the AI ​​generation unit (130). In this step, customized code (80) is generated based on context information (70) analyzed in S100 and natural language commands (60) input in S200. The code generation module (131) and code modification module (132) of the AI ​​generation unit (130) comprehensively consider the context information (70) (project structure, coding style, UI libraries, etc.) and natural language commands (60) to generate new code or modified code that 100% conforms to the rules and conventions of the target project (20) (context-based code generation step (S310)). This utilizes large-scale language model (LLM)-based reasoning and code conversion technology to ensure consistency and quality at the same level as if the code had been written manually by a developer. The design-code conversion module (133) of the AI ​​generation unit (130) receives reference information (90) and converts it to match the UI library and coding style included in the context information (70) to generate UI component code (80) (design-code conversion generation step (S320) (detailed in FIG. 6)). This automates the handoff process between design and development, thereby reducing development time and maintaining consistency in the design system. The AI ​​generation unit (130) simultaneously generates or modifies multiple files containing source code, route settings, and menu items for a new page based on the menu location selected by the user (30) (menu location-based multiple file generation step (S330) (detailed in FIG. 5)). This utilizes the menu / routing context information (70) analyzed in S103 to ensure simultaneous modification of multiple files and maintenance of consistency when adding complex functions. The location identification module (134) of the AI ​​generation unit (130) automatically identifies the location (71) within the source code of the selected UI element based on the UI element selection information (91).Next, the code modification module (132) processes the natural language command (60) based on the identified location (71) to modify the code related to the corresponding UI element (UI element location identification and processing step (S340) (described in detail in FIG. 7)). This enables precise code modification through visual interaction, thereby maximizing development productivity. As a result of this step, customized code (80) is generated.

[0075] The code application step (S400) is performed by the code application unit (140). In this step, the custom code (80) generated in S300 can be safely and efficiently applied to the file system (21) of the target project (20). The code application unit (140) checks whether there are requests for modification or creation of multiple files as a result of S300 (multiple file change request check step (S410) (described in detail in FIG. 4)). If there are multiple file change requests, all changes are temporarily stored in the memory buffer (141) of the code application unit (140) (memory buffer temporary storage step (S420) (described in detail in FIG. 4)). This can reduce file I / O overhead and increase the stability of the change operation. In the final step, the contents temporarily stored in the memory buffer (141) are written in batches to the file system (21) through the file system writing module (142) (file system batch writing step (S430) (described in detail in FIG. 4)). In the case of a single file change, it is written immediately. This batch recording method ensures the atomicity of the change operation, thereby maintaining the integrity of the file system (21) even in the event of a system error. This step is the final step of updating the application's functionality by actually reflecting the AI-generated code into the target project (20). When all steps are completed, the 'END' node is reached, and the method for generating code tailored to this project is terminated.

[0076] FIG. 4 is a flowchart that explains the code application step (S400) of the overall flowchart of FIG. 3 in more detail. In particular, when modification or creation of multiple files is requested by the AI ​​generation unit (130), the code application unit (140) utilizes a memory buffer (141) to temporarily store the changes and records them collectively to the target project's file system (21). This method is one of the important features of the present invention, which optimizes file I / O performance and ensures the stability and atomicity of the change operation.

[0077] When the code application step (S400) begins, the code application unit (140) determines whether the custom code (80) received from the AI ​​generation unit (130) requires modification or creation of multiple files within the target project (20). This is a process of checking the scope of change of the generated code and the number of target files. For example, a request to create a new page may generally involve changes to three or more files, such as component files, routing configuration files, and menu configuration files. If only one file is created or modified in the 'S300: Custom Code Generation Step' (e.g., changing only the CSS properties of a specific component), or if the changes are very small and real-time reflection is efficient, the process proceeds to the 'No (NO)' path. On the other hand, if multiple files, such as page component files, routing configuration files, and menu configuration files, need to be changed simultaneously, as in the new page creation described in FIG. 5, the process proceeds to the 'Yes (YES)' path. This determination can be made by analyzing the change plan output by the AI ​​generation unit (130).

[0078] When there is a request to modify or create multiple files ('yes'), the code application unit (140) temporarily stores all changes in a memory buffer (141) instead of immediately writing the changes to the target project's file system (21). The memory buffer (141) is a temporary storage space allocated within a volatile memory area such as RAM, and can serve to collect the contents to be changed in advance before actually writing data to the file system (21). The contents of the newly created file, the contents before and after (delta) of the file to be modified, the path of the file to be deleted, and backup information can be stored in this buffer in a structured form. At this stage, frequent write operations to the file system (21) can be prevented, and a foundation can be laid to group all changes into a single logical transaction. This reduces file I / O overhead and optimizes performance by processing multiple changes at once. In addition, by storing changes in memory, it is possible to facilitate additional processing, such as reviewing or validating the changes before the final record, thereby contributing to protecting the integrity of the file system (21) from potential errors that may occur in subsequent steps.

[0079] After all changes have been successfully temporarily stored in the memory buffer (141), the code application unit (140) can write the buffered contents in batches to the file system (21) of the target project (20) through the file system writing module (142) in the final stage. The file system writing module (142) can process multiple file change requests stored in the memory buffer (141) at once, thereby efficiently performing file creation, existing file modification, or file deletion operations. This module utilizes an optimized file writing API to minimize disk I / O and increase the reliability of change operations. This batch writing method can ensure that all changes are applied simultaneously. In other words, it can prevent an inconsistent state where only some files are changed and others are not due to system errors or exceptions occurring during a series of change operations. This is a key advantage that enhances the stability and reliability of the system by ensuring the atomicity of code application. For example, it can prevent a situation where only component files are created and route configuration files are not created when a new page is created, and can provide a basis for a complete rollback to restore the entire state before the change, whether all changes are successfully made or if some changes fail to be applied. In addition, it has the effect of reducing performance overhead caused by frequent disk write operations and reducing the load on the file system (21).

[0080] In cases where the request is not for modification or creation of multiple files ('No'), that is, when the request is for change to a single file or the scope of change is very limited, the code application unit (140) immediately writes the changes to the file system (21) of the target project (20) without passing through the memory buffer (141). This method allows for rapid reflection of changes without overhead, making it suitable for tasks such as modifying small pieces of code in real time. For example, when modifying a single line of text within a single component or changing a simple CSS property, the changes can be reflected directly to the file system (21) without unnecessary buffering, thereby providing immediate feedback to the user.

[0081] When step S430 or S431 is completed, the 'S400 exit' node is reached, and the code application step (S400) is completed.

[0082] In conclusion, the flowchart of FIG. 4 shows that the code application unit (140) of the present invention uses an optimized code application strategy according to the characteristics of the change request (multiple files vs. a single file). In particular, when multiple files are changed, temporary storage using a memory buffer (141) and batch recording (S430) to the file system (21) is a key function that significantly improves the efficiency, stability, and atomicity of the change operation, thereby ensuring that the code generated by the AI ​​system (10) can be safely integrated into the target project (20).

[0083] FIG. 5 is a flowchart illustrating in detail a menu / routing-based code generation process according to the present invention. FIG. 5 describes a process in which specific sub-steps of the context information analysis step (S100) and the customized code generation step (S300) among the overall flowchart of FIG. 3 are specified, in which a context learning unit (110) analyzes the menu structure and routing rules of a target project (20), and based thereon, an AI generation unit (130) simultaneously generates or modifies multiple files, such as source code, route settings, and menu items for a new page, based on the menu location selected by the user (30).

[0084] The context information analysis step corresponds to step S100 of FIG. 3 and is performed by the context learning unit (110). The context analyzer (113) of the context learning unit (110) deeply analyzes the source code of the target project (20) to extract the menu structure and routing rules of the current application (S103). By scanning menu configuration files (e.g., menu definition files in the form of JSON, XML, or JavaScript objects) and rendering logic of specific components (e.g., sidebar, header navigation bar) within the target project (20), the hierarchical structure of the current menus, the labels of each menu item, and the connected URL paths can be identified (menu structure analysis). For example, the relationship between top-level menus such as 'Dashboard', 'User Management', and 'Settings' and sub-menus below them such as 'User List' and 'Permission Settings' can be identified, and additional information such as icons of each menu item and access permission settings can also be analyzed. This analysis can be stored in a tree-shaped data structure. By analyzing the routing configuration files of the target project (20) (e.g., BrowserRouter and Route definitions in react-router-dom, routes array in Vue Router, RouterModule.forRoot() in Angular Router, etc.), each URL path (e.g., / admin / users) determines which component (e.g., AdminUsersPage.vue or <adminusers / >It is possible to determine whether it is connected to, parameter processing methods, authentication and authorization rules, etc. (routing rule analysis). In addition, by learning complex routing logic such as dynamic routing patterns and Route Guard settings, it is possible to lay the foundation so that the AI ​​generation unit (130) can be perfectly integrated into the existing system when adding new routes. Through this analysis, the analyzed menu / routing context information (70) is output. This information can serve as the foundation so that the AI ​​generation unit (130) can be perfectly integrated into the existing system when adding new pages.

[0085] The step of inputting a menu location selection from the user is performed by the user interface unit (120), and when the user (30) wants to create a new page, information is received regarding which menu the page will be added under and what name it will be created with. The user (30) inputs a natural language command (60) such as "Add a new consultation statistics page under the 'Consultation Management' menu" through the user interface unit (120). Along with this, the user explicitly selects the menu location where the new page will be inserted (e.g., a submenu of the 'Consultation Management' menu) through a UI such as a Tree View or a Radio Button provided in the 'New Page Add Popup / Modal Window (330)' which will be described in detail in FIG. 8 (natural language command (60) and menu location selection input). This menu location selection can be visually provided to the user based on the menu structure analyzed in S103, and the user can easily specify the desired location through intuitive navigation.

[0086] The customized code generation step (S300) is performed by the AI ​​generation unit (130), and generates customized code based on the context information (70) analyzed in S100, the natural language command (60) input in S200, and the selected menu location. S330: Simultaneous creation / modification of multiple files (new page, route, menu item) based on the menu location selected by the user. The code generation module (131) and code modification module (132) of the AI ​​generation unit (130) comprehensively consider the menu / routing context information (70) analyzed in S103 and the menu location selected by the user (30) through the user interface unit (120), and simultaneously and consistently create or modify multiple files required for the implementation of a new page (S330). Specifically, the following files may be created or modified. A main component file (e.g., CounselingStatsPage.tsx or CounselingStatsView.vue) is created to implement the functionality requested by the user (e.g., 'Counseling Statistics Page') (source code for the new page). This file can be created in full compliance with the coding style, UI libraries used (e.g., Material UI components), file naming conventions, folder structure, etc. of the target project (20). For example, it can be created in a path such as src / pages / counseling / CounselingStatsPage.tsx. Additionally, basic page structures, such as the basic page layout and placeholders for data binding, can be created together to allow the developer to start working quickly. Route configuration files (e.g., routes.js, app-routing.module.ts) can be modified or new route definitions added so that the new page component can be mapped to specific URL paths accessible within the web application (routing).During this process, consistency with existing routing rules identified in S103 can be maintained, and if necessary, authentication / authorization middleware settings can be reflected. For example, a path such as / counseling / stats can be automatically assigned, and security settings can be added so that only users with 'admin' authority can access the route. A new menu item that leads to a new page can be added to the menu location selected by the user (30). This can be done by modifying menu components or configuration files (e.g., sidebar.json or MenuComponent.vue) defined in the target project (20), such as sidebars, header navigation, and footer menus. In this process as well, the hierarchy of existing menus and UI / UX conventions analyzed in S103 are followed. For example, a submenu called 'Counseling Statistics' can be automatically added under the 'Counseling Management' menu, and the icon and access rights of that menu can also be set consistently with the existing menu. As a result of this step, a generated / modified multi-file code (80) containing the new page, route settings, and menu items can be output. Since these multiple files are closely related to each other, AI can process them simultaneously to minimize human error and drastically reduce manual work by developers.

[0087] The code application step is performed by the code application unit (140), and the generated / modified multiple file codes (80) created in S300 can be applied to the file system (21) of the target project (20) (S400). Since the generated / modified multiple file codes (80) include multiple individual file changes, the code application unit (140) can ensure efficiency and stability by temporarily storing the changes in a memory buffer (141) as described in FIG. 4 and then writing them in batches to the file system (21). This ensures the atomicity of the change operation and can improve development productivity by preventing frequent restarts of the development server.

[0088] When all steps are completed, the 'END' node is reached, and the menu / routing-based code generation method is terminated. FIG. 5 illustrates the outstanding features of the present invention, which go beyond simply generating a single code file for a single function request, and instead fully understand the complex structural requirements (menu, routing) of the application and process multiple interrelated files simultaneously and consistently, thereby drastically reducing the developer's effort.

[0089] FIG. 6 is a combination of a block diagram and a flowchart showing the process in which the AI ​​generation unit (130) of a project-customized code generation AI system (10) receives design reference information (90) from an external design tool such as Figma (121) and generates UI component code (80). The present invention innovatively improves the design-development workflow by narrowing the gap between the designer's work and the developer's code and supporting the efficient coding of the design system.

[0090] A user (30) can create a UI design for a web or mobile application using an external design tool (121) (e.g., Figma). The designer can select specific design elements, such as specific buttons, input fields, card components, or entire page layouts, and request that reference information (90) for them be extracted. This process can be automated through a plugin or built-in export function of the design tool. The external design tool (121) is a web-based collaboration tool for UI / UX design work, such as Figma, and is used by designers to define visual elements. An external design tool server (40) hosts the core functions of these design tools and can provide design data that external systems can access via an API (Application Programming Interface). For example, node information, styles, layouts, etc., of a design file can be extracted in a structured JSON format via the Figma REST API. The external design tool (121) can output reference information (90) for specific design elements selected by the user (30). This reference information (90) may include visual and functional attributes of the design system, such as the ID, name, layer structure, text content, color (HEX or RGB), font (family, size, weight), size (width, height), spacing (padding, margin), and responsive attributes (constraints, auto layout settings) of the selected design element. This reference information (90) is transmitted to the user interface unit (120). (Step S210)

[0091] The user interface section (120) of the project-customized code generation AI system (10) receives reference information (90) transmitted from an external design tool (121). This input can be made through various methods, such as direct API integration, data transmission via a dedicated plugin, or by the user manually copying and pasting information from the design tool. The user interface section (120) can perform necessary preprocessing work before transmitting this information to the AI ​​generation section (130).

[0092] The context learning unit (110) provides context information (70) learned from the source code of the target project (20) to the AI ​​generation unit (130). Here, the context information (70) may include, in particular, information about the UI libraries used by the target project (20) (e.g., frameworks such as React, Vue, and Angular, and UI component libraries actually in use such as Material-UI, Ant Design, and Tailwind CSS) and coding styles (e.g., JSX / TSX component structure, Vue single-file component structure, CSS-in-JS patterns (e.g., styled-components), file naming conventions, props passing methods, theme settings, etc.). This information can play a key role in ensuring that when design elements are converted into actual code, they conform 100% to the project's unique technology stack and conventions.

[0093] The AI ​​generation unit (130) generates UI component code (80) by utilizing reference information (90) received from the user interface unit (120) and context information (70) provided by the context learning unit (110). Design-Code Conversion Module (133): The design-code conversion module (133) within the AI ​​generation unit (130) can perform a key role in generating UI component code (80) by converting the design corresponding to the reference information (90) to match the UI library and coding style of the target project (20). For example, it can receive reference information (90) for a 'Primary Button' design element defined in Figma. This information may include attributes such as the button's text, background color, font, and rounded corners. Through the context information (70), it can identify that the target project (20) uses React and Material-UI and has a specific color palette and font style. Additionally, it can learn standard prop usage methods for button components (e.g., variant, color). The design-code conversion module (133) is based on this and the Material-UI's <button>You can generate UI component code (80) by using a component and applying React JSX code with props and styles such as variant="contained", color="primary", sx={{ fontSize: '1rem', padding: '10px 20px', borderRadius: '8px'}} according to the style guidelines of the target project (20). In this case, if Figma's font size '16px' can be mapped to the project's design system token 'font-size-md', then using this <typography sx="{{" fontsize: 'font-size-md'}}>Consistency can be further enhanced by generating it as shown above. Similarly, for complex layouts or component combinations defined by Figma’s Auto Layout, code can be generated in a responsive and reusable form by utilizing the UI library’s Flexbox or Grid systems (e.g., Material-UI’s Box with display="flex" or Grid component). In this process, spacing tokens within the design system (e.g., theme.spacing(2)) can be automatically applied to maintain consistent spacing. (Step S320)

[0094] The UI component code (80) generated by the AI ​​generation unit (130) is transferred to the code application unit (140). The code application unit (140) can apply the generated UI component code (80) by creating a new file in an appropriate location (e.g., src / components directory or src / ui / buttons directory) within the file system (21) of the target project (20), or by modifying the contents of an existing file. In this process, stable and efficient application can be achieved through the memory buffering and batch writing mechanism described in FIG. 4. This prevents frequent restarts of the development server and ensures the reliability of the code application.

[0095] Figure 6 visualizes the process in which a visual design generated during the design phase is automatically converted into code during the development phase without manual conversion. This strengthens the consistency of the design system, significantly improves the efficiency of collaboration between designers and developers, and can shorten UI development time, thereby fundamentally resolving the chronic problem of "discrepancy between design mockups and actual implementations."

[0096] FIG. 7 is a combination of a block diagram and a flowchart illustrating the process in which a user (30) visually selects a specific UI element on a screen rendered on a web browser (50), and a project-specific code generation AI system (10) automatically identifies the location (71) of the UI element within the source code and processes a natural language command (60). The present invention can maximize the productivity and convenience of developers by highly refining and simplifying code modification work through intuitive visual interaction.

[0097] The user (30) can directly select a specific UI element (e.g., button, input field, image, text block, entire card component, etc.) to modify by visual means such as a mouse click while viewing the application screen rendered on the web browser (50). This selection process is similar to the 'Inspect Element' function of general developer tools, but it has the characteristic of collecting information for integration with the AI ​​system (10) beyond simply displaying DOM information. The web browser (50) can render the application of the target project (20) and provide a UI element picker (Visual Picker, 122) function embedded in or integrated with the user interface section (120). This picker (122) can perform the role of obtaining DOM (Document Object Model) information (e.g., HTML element tag name, ID, CSS class, attributes, DOM path (XPath or CSS Selector), text content, bounding box coordinates, parent-child relationship, etc.) or unique identifier of the element when the user clicks on a UI element on the screen. This selector (122) can be implemented via a browser extension or an injected SDK script. The UI element selector (122) can output UI element selection information (91) for a specific UI element selected by the user (30). This information (91) includes all metadata necessary to map the selected UI element to source code and is transmitted to the user interface section (120). (Step S220)

[0098] The user interface section (120) of the project-customized code generation AI system (10) receives UI element selection information (91) transmitted from the UI element selector (122). At the same time, the user (30) can input natural language commands (60) for the task to be performed on the selected UI element. For example, after selecting a button, the user can input commands such as "Change the text of this button to 'OK'", "Set the initial value of this input field to 'admin@example.com'", or "Change the width of this image to 200px". These natural language commands (60) can serve as a means to clearly convey the user's intent to the AI ​​system (10).

[0099] The context learning unit (110) can provide context information (70) learned from the source code of the target project (20) to the AI ​​generation unit (130). This context information (70) may include all information necessary to identify and modify source code associated with UI element selection information (91), such as the component structure of the target project (20) (e.g., which component is defined in which file, hierarchical relationships between components), file organization, coding style (e.g., CSS-in-JS, Tailwind CSS), and usage of the UI library used. This information can enable complex mapping between UI elements and actual code.

[0100] The AI ​​generation unit (130) can perform code modification by utilizing UI element selection information (91) received from the user interface unit (120), natural language commands (60), and context information (70) provided by the context learning unit (110). The location identification module (134) within the AI ​​generation unit (130) can perform a key role in automatically identifying the location (71) within the source code of the selected UI element based on the UI element selection information (91) (e.g., DOM path / html / body / div / button[@id='login-button'], text 'Sign In'), determining exactly which file and which code line the UI element corresponds to among the numerous source code files of the target project (20). This process can generate a mapping between the rendered UI and the source code by utilizing static / dynamic code analysis techniques similar to the context analyzer (113) of the context learning unit (110). For example, a button with the ID 'login-button' and a button with the text 'Sign In' in the src / components / auth / LoginComponent.tsx file< / typography> < / button> <button id="login-button">Sign In< / button> It can be identified that it is defined on the line where the element is located. Additionally, the CSS file or styled-components definition used by the component can also be identified. (Step S340) Based on the location (71) within the source code of the selected UI element identified by the location identification module (134), the code modification module (132) can modify the source code by processing natural language commands (60). For example, if a command is given such as "Change the text of this button to 'Login' and make the color blue," and the location (71) within the button's source code is within the LoginComponent.tsx file <button id="login-button"> Sign In< / button> If identified as such, the code modification module (132) <button id="login-button" color="primary"> log in< / button>Custom code (80) can be generated to modify it. In this case, the natural language 'blue' can be converted into appropriate color props according to the project's theme settings (e.g., the primary color of Material-UI) included in the context information (70). Even during this modification process, the coding style and conventions included in the context information (70) can be fully adhered to to maintain consistency with the existing code.

[0101] The (modified) customized code (80) generated by the AI ​​generation unit (130) is transferred to the code application unit (140). The code application unit (140) applies the modified customized code (80) to a file corresponding to a location (71) within the identified source code in the file system (21) of the target project (20). In this process, stable and efficient application can be achieved through the memory buffering and batch writing mechanism described in FIG. 4, which prevents frequent restarts of the development server and improves development productivity.

[0102] FIG. 7 illustrates the core user experience of the present invention, which can drastically reduce the complexity of code modification and innovatively increase development productivity by allowing the user (30) to intuitively specify the target for modification and issue commands in natural language on the operating screen of the application, instead of directly visiting and modifying the code. This provides a very strong advantage, especially in front-end development and UI / UX-related code modification tasks, and can support non-developers in safely modifying the screen.

[0103] FIG. 8 is a screen configuration diagram that visually illustrates a menu generation scenario through the user interface section (120) of a project-customized code generation AI system (10). FIG. 8 explains, through specific UI (User Interface) elements, how the menu / routing-based code generation function described in FIG. 5 is provided to the user (30) and how the user (30) interacts with natural language commands (60) to integrate a new page into the existing menu structure. This is an example showing the contents of claims 3 and 8 from the perspective of actual user experience. FIG. 8 is based on the screen configuration of a general web application and includes the following key UI elements.

[0104] The web browser screen (50) and main area Fig. 8 shows the application screen rendered on the web browser (50) overall. This screen is largely divided into a main content area (300) and a menu / sidebar area (310). This is the area where the core content of the application is displayed. In this example, it shows a screen where a specific statistics dashboard is rendered. An AI agent dialog box (320) or a new page add popup (330), etc., may appear as an overlay on this area, and it is the space where the main user operations take place. The menu / sidebar area (310) is positioned vertically on the left side of the screen and shows the menu structure for the overall navigation of the application. This area can visually represent the structural hierarchy of the application.

[0105] UI element menu items (311) within the menu / sidebar area (310) display the existing menu list of the application, such as 'Dashboard', 'Consultation Management', 'AI Analysis Dashboard', and 'Consultation Statistics'. In particular, it can show that sub-menu items (311), such as 'Consultation Calls by Date', are hierarchically organized under 'Consultation Statistics'. This is a visual representation of the menu structure context information (70) analyzed by the context learning unit (110) in step S103, and can clearly present the navigation structure of the current application to the user. Each menu item performs the function of moving to the corresponding page when clicked. The AI ​​agent button (312) can be located within the menu / sidebar area (310) and is a button that activates the AI ​​agent dialog box (320) when clicked. It serves as an entry point where the user (30) begins interacting with the project-customized code generation AI system (10) and can generally be displayed as an icon or a concise text label.

[0106] The AI ​​agent dialog box (320) is a conversational interface that appears as an overlay at the bottom left of the screen when the AI ​​agent button (312) is clicked, and is one of the core components of the user interface section (120). The natural language command input field (321) is a field where the user (30) can input natural language commands (60) in text form. For example, commands such as "Create a new consultation status page" or "Add a chart component to this page" can be entered, and this can be used as input for the AI ​​generation section (130). The page add button (322) is located within the AI ​​agent dialog box (320) and is a shortcut button that allows for quick execution of specific functions. When clicked, it calls the 'new page add popup / modal window (330)' to start creating a menu-based page. This can increase usability by providing an interface for specific actions in addition to the natural language command (60) input in the S200 stage. The AI ​​response message (325) is an area where the AI ​​system (10) displays a response or status message to a user's (30) request. For example, it can display a message such as "Automatically detected the current home page. Which page would you like to create?" to guide the user to the next step or provide feedback on the progress of the task.

[0107] The new page add popup / modal window (330) is a popup window that appears as an overlay in the center of the main content area (300) when the page add button (322) is clicked. This window can provide a UI for the user (30) to enter detailed information required to create a new page. The page name input field (331) is a text field for the user (30) to enter a name to be used to determine the internal code name or file name of the new page to be created. For example, 'CounselingStatusPage' can be entered, and the AI ​​system (10) automatically generates a file name (CounselingStatusPage.tsx) or component name (CounselingStatusPage) based on this name. The menu label input field (332) is a text field for the user (30) to enter a label to be displayed on the menu item connected to the new page. For example, 'Counseling Status' can be entered, and this label is used as the actual menu name to be displayed in the menu / sidebar area (310). The additional location selection tree view / radio button (333) is a key part that visually implements the 'user-selected menu location' of claims 3 and 8. The context learning unit (110) displays the existing menu structure context information (70) analyzed in step S103 in a tree form (Tree View) or presents it as a list of radio buttons, allowing the user (30) to intuitively select which existing menu item (311) the menu item of the page to be newly created will be located under. For example, the user (30) can select 'Consultation Statistics > Consultation Calls by Date' to specify that the newly created 'Consultation Status' menu be added as a sub-menu of the 'Consultation Calls by Date' menu. This is a specific example of the menu location selection input in step S200, and allows the user to easily change the menu structure through the GUI without needing to directly access a complex configuration file.After entering all information and selecting a menu location, when the user (30) clicks the create button (334), the AI ​​creation unit (130) of the AI ​​system (10) starts the task of simultaneously creating or modifying multiple files including source code, route settings, and menu items of a new page based on the menu location selected in step S330.

[0108] After clicking the create button (334), a small message box may be displayed in a suitable location on the screen (e.g., within a top banner or popup) to inform the user (30) in real time of the progress of the work performed by the AI ​​creation unit (130) and code application unit (140) of the AI ​​system (10), such as 'Creating test component page (1 / 4)' and 'Route registration (2 / 4)'. This provides feedback on the background work of the S300 and S400 stages, which can reduce the user's (30) waiting time and increase their confidence. This transparent progress display helps the user understand and predict the system's operation.

[0109] FIG. 8 clearly shows how the user interface section (120) of the project-customized code generation AI system (10) visualizes context information obtained from the context learning section (110) and facilitates complex code generation and modification tasks through the intuitive input (natural language commands and UI selection) of the user (30). In particular, the additional location selection tree view (333) clearly demonstrates how deeply the AI ​​system (10) understands the structural context of the application and provides this information for the user (30) to utilize. Through this, the user (30) can quickly and accurately extend the core functions of the application without writing code directly, and can provide a foundation for non-developers to safely participate in the development process. Explanation of the symbols

[0111] 10: Project-Customized Code Generation AI System 20: Target Project 30 : User 110 : Context learning section 120: User Interface Section 130 : AI Generation Unit 140 : Code application section

Claims

Claim 1 In an AI system for generating project-specific code, the system comprises: a context learning unit injected into a target project via a Software Development Kit (SDK) to scan the source code of the target project and automatically analyze context information including project structure, coding style, and UI libraries used; a user interface unit that receives natural language commands from a user for code generation or modification; an AI generation unit that generates customized code conforming to the rules and conventions of the target project based on the analyzed context information and the input natural language commands; and a code application unit that applies the generated customized code to the file system of the target project. A project-customized code generation AI system further comprising a job queue management unit that defines the natural language command input through the user interface unit as an individual job, assigns a unique job identifier (Job ID), and manages it by registering it in a queue; wherein the job queue management unit controls access to the code application unit at a time according to the order registered in the queue when simultaneous natural language commands are input from multiple users, thereby preventing data access conflicts (race conditions) that may occur during the process of the code application unit applying code to the file system, and determines the status information of the corresponding job as one of Pending, Processing, Done, or Failed according to the progress stage of each job and updates it in memory in real time. Claim 2 delete Claim 3 A project-customized code generation AI system according to claim 1, wherein the code application unit, when a request for modification or generation of multiple files is made by the AI ​​generation unit, temporarily stores all changes in a memory buffer and then writes them collectively to the file system of the target project in the final stage. Claim 4 A project-customized code generation AI system according to claim 1, wherein the context learning unit analyzes the menu structure and routing rules of the target project, and the AI ​​generation unit simultaneously generates or modifies a plurality of files including source code, route settings, and menu items for a new page based on a menu location selected by the user through the user interface unit. Claim 5 A project-customized code generation AI system according to claim 1, wherein the user interface unit receives reference information regarding specific design elements of an external design tool, and the AI ​​generation unit converts the design corresponding to the input reference information to match the UI library and coding style included in the analyzed context information to generate UI component code. Claim 6 A project-customized code generation AI system according to claim 1, wherein the user interface unit provides a function that allows a user to select (visual picking) a specific UI element on a screen rendered on a web browser, and the AI ​​generation unit automatically identifies the location of the selected UI element within the source code and processes the natural language command based on the identified location. Claim 7 A method for generating custom code for a project executed by a computer comprises: (a) a step of automatically analyzing context information including project structure, coding style, and UI libraries used by scanning the source code of the target project, which is injected into the target project through an SDK (Software Development Kit); (b) a step of receiving a natural language command for code generation or modification from a user; (c) a step of generating custom code that conforms to the rules and conventions of the target project based on the analyzed context information and the input natural language command; and (d) a step of applying the generated custom code to the file system of the target project. and (e) a job queue management step comprising defining the received natural language command as an individual job, assigning a unique job identifier (Job ID), and registering and managing it in a queue, wherein the job queue management step, when receiving simultaneous natural language commands from multiple users, controls that only one job is applied to the file system at a time according to the order registered in the queue, thereby preventing a data access conflict (Race Condition) that may occur during the process of applying code to the file system, and determines the status information of the corresponding job as one of Pending, Processing, Done, or Failed according to the progress stage of each job and updates it in memory in real time. Claim 8 A method for generating project-specific code according to claim 7, wherein step (d) is characterized by temporarily storing all changes in a memory buffer and then writing them collectively to the file system of the target project in the final step, when modification or creation of multiple files is required as a result of step (c). Claim 9 A method for generating project-specific code according to claim 7, wherein step (a) further includes analyzing the menu structure and routing rules of the target project, and step (c) automatically generates source code, route settings, and menu items for a new page based on a menu location selected by the user.

Citation Information

Patent Citations

  • Method, apparatus and computer-readable recording medium for automatically generating user interface screen design and source code based on json events using ai responses

    KR1020250136270A

  • AI based prompt automatic generation system and method using context information in development tool and program performing the same

    KR102876286B1

  • System and method for multi-layer memory-based dynamic context generation

    KR102892588B1